BUGFIX: make tethered node ids deterministic

Neos.ContentRepository.Core/Classes/Feature/NodeCreation/Command/CreateNodeAggregateWithNode.php

@@ -58,6 +58,9 @@ final class CreateNodeAggregateWithNode implements CommandInterface
      * using this assignment registry.
      * Since tethered child nodes may have tethered child nodes themselves,
      * this registry is indexed using relative node paths to the node to create in the first place.
+     *
+     * Specifying them is optional, and otherwise they are calculated deterministic based on the $nodeAggregateId and the tethered nodeName.
+     * So you can determine the child node identifier via {@see NodeAggregateId::fromParentNodeAggregateIdAndNodeName()}
      */
     public readonly NodeAggregateIdsByNodePaths $tetheredDescendantNodeAggregateIds;
 

Neos.ContentRepository.Core/Classes/Feature/NodeCreation/NodeCreation.php

@@ -199,10 +199,9 @@ private function handleCreateNodeAggregateWithNodeAndSerializedProperties(
                 $contentRepository
             );
         }
-        $descendantNodeAggregateIds = self::populateNodeAggregateIds(
-            $nodeType,
-            $command->tetheredDescendantNodeAggregateIds
-        );
+
+        $descendantNodeAggregateIds = $nodeType->tetheredNodeAggregateIds($command->nodeAggregateId)
+            ->merge($command->tetheredDescendantNodeAggregateIds);
         // Write the auto-created descendant node aggregate ids back to the command;
         // so that when rebasing the command, it stays fully deterministic.
         $command = $command->withTetheredDescendantNodeAggregateIds($descendantNodeAggregateIds);
@@ -338,29 +337,4 @@ private function createTetheredWithNode(
             $precedingNodeAggregateId
         );
     }
-
-    protected static function populateNodeAggregateIds(
-        NodeType $nodeType,
-        ?NodeAggregateIdsByNodePaths $nodeAggregateIds,
-        NodePath $childPath = null
-    ): NodeAggregateIdsByNodePaths {
-        if ($nodeAggregateIds === null) {
-            $nodeAggregateIds = NodeAggregateIdsByNodePaths::createEmpty();
-        }
-        // TODO: handle Multiple levels of autocreated child nodes
-        foreach ($nodeType->getAutoCreatedChildNodes() as $rawChildName => $childNodeType) {
-            $childName = NodeName::fromString($rawChildName);
-            $childPath = $childPath
-                ? $childPath->appendPathSegment($childName)
-                : NodePath::fromString($childName->value);
-            if (!$nodeAggregateIds->getNodeAggregateId($childPath)) {
-                $nodeAggregateIds = $nodeAggregateIds->add(
-                    $childPath,
-                    NodeAggregateId::create()
-                );
-            }
-        }
-
-        return $nodeAggregateIds;
-    }
 }

Neos.ContentRepository.Core/Classes/Feature/NodeTypeChange/NodeTypeChange.php

@@ -87,12 +87,6 @@ abstract protected function areNodeTypeConstraintsImposedByGrandparentValid(
         NodeType $nodeType
     ): bool;
 
-    abstract protected static function populateNodeAggregateIds(
-        NodeType $nodeType,
-        NodeAggregateIdsByNodePaths $nodeAggregateIds,
-        NodePath $childPath = null
-    ): NodeAggregateIdsByNodePaths;
-
     abstract protected function createEventsForMissingTetheredNode(
         NodeAggregate $parentNodeAggregate,
         Node $parentNode,
@@ -156,10 +150,9 @@ private function handleChangeNodeAggregateType(
         /**************
          * Preparation - make the command fully deterministic in case of rebase
          **************/
-        $descendantNodeAggregateIds = static::populateNodeAggregateIds(
-            $newNodeType,
-            $command->tetheredDescendantNodeAggregateIds
-        );
+        $descendantNodeAggregateIds = $newNodeType->tetheredNodeAggregateIds($command->nodeAggregateId)
+            ->merge($command->tetheredDescendantNodeAggregateIds ?? NodeAggregateIdsByNodePaths::createEmpty());
+
         // Write the auto-created descendant node aggregate ids back to the command;
         // so that when rebasing the command, it stays fully deterministic.
         $command = $command->withTetheredDescendantNodeAggregateIds($descendantNodeAggregateIds);

Neos.ContentRepository.Core/Classes/NodeType/NodeType.php

@@ -15,7 +15,10 @@
  */
 
 
+use Neos\ContentRepository\Core\Feature\NodeCreation\Dto\NodeAggregateIdsByNodePaths;
+use Neos\ContentRepository\Core\Projection\ContentGraph\NodePath;
 use Neos\ContentRepository\Core\SharedModel\Exception\NodeTypeNotFoundException;
+use Neos\ContentRepository\Core\SharedModel\Node\NodeAggregateId;
 use Neos\ContentRepository\Core\SharedModel\Node\NodeName;
 use Neos\Utility\ObjectAccess;
 use Neos\Utility\Arrays;
@@ -490,11 +493,31 @@ public function hasAutoCreatedChildNode(NodeName $nodeName): bool
      */
     public function getTypeOfAutoCreatedChildNode(NodeName $nodeName): ?NodeType
     {
+        $this->initialize();
         return isset($this->fullConfiguration['childNodes'][$nodeName->value]['type'])
             ? $this->nodeTypeManager->getNodeType($this->fullConfiguration['childNodes'][$nodeName->value]['type'])
             : null;
     }
 
+    /**
+     * Calculates the deterministic nodeAggregateIds for the auto-created childNodes.
+     */
+    public function tetheredNodeAggregateIds(NodeAggregateId $parentNodeAggregateId): NodeAggregateIdsByNodePaths
+    {
+        $this->initialize();
+        $nodeAggregateIdsByNodePaths = NodeAggregateIdsByNodePaths::createEmpty();
+        if (!isset($this->fullConfiguration['childNodes'])) {
+            return $nodeAggregateIdsByNodePaths;
+        }
+        // TODO: handle Multiple levels of autocreated child nodes
+        foreach (array_keys($this->fullConfiguration['childNodes']) as $tetheredNodeName) {
+            $nodeAggregateIdsByNodePaths = $nodeAggregateIdsByNodePaths->add(
+                NodePath::fromString($tetheredNodeName),
+                NodeAggregateId::fromParentNodeAggregateIdAndNodeName($parentNodeAggregateId, NodeName::fromString($tetheredNodeName))
+            );
+        }
+        return $nodeAggregateIdsByNodePaths;
+    }
 
     /**
      * Checks if the given NodeType is acceptable as sub-node with the configured constraints,

Neos.ContentRepository.Core/Classes/SharedModel/Node/NodeAggregateId.php

@@ -50,6 +50,23 @@ public static function fromString(string $value): self
         return new self($value);
     }
 
+    /**
+     * Calculates a deterministic nodeAggregateId.
+     *
+     * Used for determining the nodeAggregateIds of tethered nodes.
+     *
+     * e.g. in case you want to get the main content collection node aggregate id:
+     *  NodeAggregateId::fromParentNodeAggregateIdAndNodeName($parentNodeAggregateId, NodeName::fromString('main'))
+     *
+     */
+    public static function fromParentNodeAggregateIdAndNodeName(NodeAggregateId $parentNodeAggregateId, NodeName $tetheredNodeName): self
+    {
+        $hex = md5($parentNodeAggregateId->value . '-' . $tetheredNodeName->value);
+        return new self(
+            substr($hex, 0, 8) . '-' . substr($hex, 8, 4) . '-' . substr($hex, 12, 4) . '-' . substr($hex, 16, 4) . '-' . substr($hex, 20, 12)
+        );
+    }
+
     public function equals(self $other): bool
     {
         return $this->value === $other->value;