WIP: FEATURE: New reference editor (DD Sprint)

.editorconfig

@@ -6,7 +6,7 @@ trim_trailing_whitespace = true
 indent_style = space
 indent_size = 4
 
-[*.{yml,yaml,json,xlf}]
+[*.{yml,yaml,feature,json,xlf}]
 indent_size = 2
 
 [*.md]

Classes/Domain/Model/Changes/Reference.php

@@ -0,0 +1,139 @@
+<?php
+declare(strict_types=1);
+namespace Neos\Neos\Ui\Domain\Model\Changes;
+
+/*
+ * This file is part of the Neos.Neos.Ui package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+use Neos\ContentRepository\Core\Feature\NodeModification\Dto\PropertyValuesToWrite;
+use Neos\ContentRepository\Core\Feature\NodeReferencing\Command\SetNodeReferences;
+use Neos\ContentRepository\Core\Feature\NodeReferencing\Dto\NodeReferencesForName;
+use Neos\ContentRepository\Core\Feature\NodeReferencing\Dto\NodeReferencesToWrite;
+use Neos\ContentRepository\Core\Feature\NodeReferencing\Dto\NodeReferenceToWrite;
+use Neos\ContentRepository\Core\SharedModel\Node\NodeAggregateId;
+use Neos\ContentRepository\Core\SharedModel\Node\ReferenceName;
+use Neos\Neos\Ui\Domain\Model\AbstractChange;
+use Neos\Neos\Ui\Domain\Model\Feedback\Operations\ReloadContentOutOfBand;
+use Neos\Neos\Ui\Domain\Model\Feedback\Operations\UpdateNodeInfo;
+use Neos\Neos\Ui\Domain\Model\RenderedNodeDomAddress;
+
+/**
+ * Changes a reference on a node
+ * @internal These objects internally reflect possible operations made by the Neos.Ui.
+ *           They are sorely an implementation detail. You should not use them!
+ *           Please look into the php command API of the Neos CR instead.
+ */
+class Reference extends AbstractChange
+{
+    public function __construct(
+        // private Node $subject, lol todo
+        private string $referenceName,
+        private ?RenderedNodeDomAddress $nodeDomAddress,
+        private array $serializedReferences
+    ) {
+    }
+
+    public function canApply(): bool
+    {
+        $nodeType = $this->getNodeType($this->subject);
+        if (!$nodeType) {
+            return false;
+        }
+        return $nodeType->hasReference($this->referenceName);
+    }
+
+    public function apply(): void
+    {
+        if ($this->canApply() === false) {
+            return;
+        }
+
+        $this->handleNodeReferenceChange();
+        $this->createFeedback();
+    }
+
+    private function createFeedback(): void
+    {
+        $subject = $this->subject;
+
+        // We have to refetch the Node after modifications because its a read-only model
+        // These 'Change' classes have been designed with mutable Neos < 9 Nodes and thus this might seem hacky
+        // When fully redesigning the Neos Ui php integration this will fixed
+        $subgraph = $this->contentRepositoryRegistry->subgraphForNode($subject);
+        $originalNodeAggregateId = $subject->aggregateId;
+        $node = $subgraph->findNodeById($originalNodeAggregateId);
+        if (is_null($node)) {
+            throw new \InvalidArgumentException(
+                'Cannot apply reference on missing node ' . $originalNodeAggregateId->value,
+                1645560836
+            );
+        }
+
+        $this->updateWorkspaceInfo();
+        $parentNode = $subgraph->findParentNode($node->aggregateId);
+
+        // This might be needed to update node label and other things that we can calculate only on the server
+        $updateNodeInfo = new UpdateNodeInfo();
+        $updateNodeInfo->setNode($node);
+        $this->feedbackCollection->add($updateNodeInfo);
+
+        $reloadIfChangedConfigurationPathForReference = sprintf('references.%s.ui.reloadIfChanged', $this->referenceName);
+        if (
+            $this->getNodeType($node)?->getConfiguration($reloadIfChangedConfigurationPathForReference)
+        ) {
+            if (!$this->nodeDomAddress) {
+                $this->reloadDocument($node);
+            } elseif ($this->nodeDomAddress->getFusionPath()
+                && $parentNode
+                && $this->getNodeType($parentNode)?->isOfType('Neos.Neos:ContentCollection')) {
+                $reloadContentOutOfBand = new ReloadContentOutOfBand();
+                $reloadContentOutOfBand->setNode($node);
+                $reloadContentOutOfBand->setNodeDomAddress($this->nodeDomAddress);
+                $this->feedbackCollection->add($reloadContentOutOfBand);
+            } else {
+                $this->reloadDocument($node);
+            }
+        }
+
+        $reloadPageIfChangedConfigurationPathForReference = sprintf('references.%s.ui.reloadPageIfChanged', $this->referenceName);
+        if (
+            $this->getNodeType($node)?->getConfiguration($reloadPageIfChangedConfigurationPathForReference)
+        ) {
+            $this->reloadDocument($node);
+        }
+    }
+
+    private function handleNodeReferenceChange(): void
+    {
+        $contentRepository = $this->contentRepositoryRegistry->get($this->subject->contentRepositoryId);
+
+        $nodeReferencesToWrite = [];
+        foreach ($this->serializedReferences as $serializedReference) {
+            $nodeReferencesToWrite[] = NodeReferenceToWrite::fromTargetAndProperties(
+                target: NodeAggregateId::fromString($serializedReference['targetNodeId']),
+                properties: PropertyValuesToWrite::fromArray($serializedReference['properties'] ?? [])
+            );
+        }
+
+        $contentRepository->handle(
+            SetNodeReferences::create(
+                $this->subject->workspaceName,
+                $this->subject->aggregateId,
+                $this->subject->originDimensionSpacePoint,
+                NodeReferencesToWrite::create(
+                    NodeReferencesForName::fromReferences(
+                        ReferenceName::fromString($this->referenceName),
+                        $nodeReferencesToWrite
+                    )
+                )
+            )
+        );
+    }
+}

Classes/Domain/Model/RenderedNodeDomAddress.php

@@ -31,6 +31,14 @@
      */
     protected $fusionPath;
 
+    public static function fromArray(array $array): self
+    {
+        $me = new self();
+        $me->contextPath = $array['contextPath'];
+        $me->fusionPath = $array['fusionPath'];
+        return $me;
+    }
+
     /**
      * Set the context path
      *

Classes/Domain/Service/NodePropertyConverterService.php

@@ -16,6 +16,7 @@
 
 use Neos\ContentRepository\Core\Feature\SubtreeTagging\Dto\SubtreeTag;
 use Neos\ContentRepository\Core\NodeType\NodeType;
+use Neos\ContentRepository\Core\Projection\ContentGraph\Filter\CountReferencesFilter;
 use Neos\ContentRepository\Core\Projection\ContentGraph\Filter\FindReferencesFilter;
 use Neos\ContentRepository\Core\Projection\ContentGraph\Node;
 use Neos\ContentRepositoryRegistry\ContentRepositoryRegistry;
@@ -100,17 +101,18 @@
     }
 
     /**
+     * todo remove all
      * @return list<string>|string|null
      */
-    private function getReference(Node $node, string $referenceName): array|string|null
+    private function getReferencesCount(Node $node, string $referenceName): int
     {
         $subgraph = $this->contentRepositoryRegistry->subgraphForNode($node);
-        $references = $subgraph->findReferences(
+        return $subgraph->countReferences(
             $node->aggregateId,
-            FindReferencesFilter::create(referenceName: $referenceName)
+            CountReferencesFilter::create(referenceName: $referenceName)
         );
 
         $referenceIdentifiers = [];
         foreach ($references as $reference) {
             $referenceIdentifiers[] = $reference->node->aggregateId->value;
         }
@@ -182,7 +184,9 @@
             $properties[$propertyName] = $this->getProperty($node, $propertyName);
         }
         foreach ($this->getNodeType($node)->getReferences() as $referenceName => $_) {
-            $properties[$referenceName] = $this->getReference($node, $referenceName);
+            $properties[$referenceName] = [
+                'referencesCount' => $this->getReferencesCount($node, $referenceName)
+            ];
         }
         return $properties;
     }

Classes/ReferencesEditor/Application/GetChildrenForTreeNode/Controller/GetChildrenForTreeNodeController.php

@@ -0,0 +1,51 @@
+<?php
+
+/*
+ * This file is part of the Neos.Neos.Ui package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+declare(strict_types=1);
+
+namespace Neos\Neos\Ui\ReferencesEditor\Application\GetChildrenForTreeNode\Controller;
+
+use Neos\Flow\Annotations as Flow;
+use Neos\Neos\FrontendRouting\SiteDetection\SiteDetectionResult;
+use Neos\Neos\Ui\Infrastructure\MVC\AbstractQueryController;
+use Neos\Neos\Ui\Infrastructure\MVC\QueryResponseHelper;
+use Neos\Neos\Ui\ReferencesEditor\Application\GetChildrenForTreeNode\GetChildrenForTreeNodeQuery;
+use Neos\Neos\Ui\ReferencesEditor\Application\GetChildrenForTreeNode\GetChildrenForTreeNodeQueryHandler;
+use Neos\Neos\Ui\LinkEditor\Application\Shared\NodeWasNotFound;
+use Psr\Http\Message\ResponseInterface;
+
+#[Flow\Scope("singleton")]
+final class GetChildrenForTreeNodeController extends AbstractQueryController
+{
+    #[Flow\Inject]
+    protected GetChildrenForTreeNodeQueryHandler $queryHandler;
+
+    #[Flow\Route('neos/references-editor/get-children-for-tree-node')]
+    public function processQueryAction(): ResponseInterface
+    {
+        $arguments = $this->request->getArguments();
+        if (!isset($arguments['contentRepositoryId'])) {
+            /** @todo send from UI */
+            $siteDetectionResult = SiteDetectionResult::fromRequest($this->request->getHttpRequest());
+            $arguments['contentRepositoryId'] = $siteDetectionResult->contentRepositoryId->value;
+        }
+
+        try {
+            $query = GetChildrenForTreeNodeQuery::fromArray($arguments);
+            $queryResult = $this->queryHandler->handle($query);
+
+            return QueryResponseHelper::createSuccess($queryResult);
+        } catch (NodeWasNotFound $e) {
+            return QueryResponseHelper::createServerSideErrorForBadRequest($e);
+        }
+    }
+}

Classes/ReferencesEditor/Application/GetChildrenForTreeNode/GetChildrenForTreeNodeQuery.php

@@ -0,0 +1,75 @@
+<?php
+
+/*
+ * This file is part of the Neos.Neos.Ui package.
+ *
+ * (c) Contributors of the Neos Project - www.neos.io
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+declare(strict_types=1);
+
+namespace Neos\Neos\Ui\ReferencesEditor\Application\GetChildrenForTreeNode;
+
+use Neos\ContentRepository\Core\DimensionSpace\DimensionSpacePoint;
+use Neos\ContentRepository\Core\NodeType\NodeTypeNames;
+use Neos\ContentRepository\Core\SharedModel\ContentRepository\ContentRepositoryId;
+use Neos\ContentRepository\Core\SharedModel\Node\NodeAggregateId;
+use Neos\ContentRepository\Core\SharedModel\Workspace\WorkspaceName;
+use Neos\Flow\Annotations as Flow;
+
+/**
+ * @internal
+ */
+#[Flow\Proxy(false)]
+final class GetChildrenForTreeNodeQuery
+{
+    public function __construct(
+        public readonly ContentRepositoryId $contentRepositoryId,
+        public readonly WorkspaceName $workspaceName,
+        public readonly DimensionSpacePoint $dimensionSpacePoint,
+        public readonly NodeAggregateId $treeNodeId,
+        public readonly string $nodeTypeFilter,
+        public readonly NodeTypeNames $allowedNodeTypes,
+    ) {
+    }
+
+    /**
+     * @param array<string,mixed> $array
+     */
+    public static function fromArray(array $array): self
+    {
+        isset($array['contentRepositoryId'])
+            or throw new \InvalidArgumentException('Content Repository Id must be set');
+        is_string($array['contentRepositoryId'])
+            or throw new \InvalidArgumentException('Content Repository Id must be a string');
+
+        isset($array['workspaceName'])
+            or throw new \InvalidArgumentException('Workspace name must be set');
+        is_string($array['workspaceName'])
+            or throw new \InvalidArgumentException('Workspace name must be a string');
+
+        isset($array['treeNodeId'])
+            or throw new \InvalidArgumentException('Tree node id must be set');
+        is_string($array['treeNodeId'])
+            or throw new \InvalidArgumentException('Tree node id must be a string');
+
+        !isset($array['nodeTypeFilter']) or is_string($array['nodeTypeFilter'])
+            or throw new \InvalidArgumentException('Node type filter must be a string');
+
+        !isset($array['allowedNodeTypes']) or is_array($array['allowedNodeTypes'])
+            or throw new \InvalidArgumentException('allowed node types must be an array');
+
+        return new self(
+            contentRepositoryId: ContentRepositoryId::fromString($array['contentRepositoryId']),
+            workspaceName: WorkspaceName::fromString($array['workspaceName']),
+            dimensionSpacePoint: DimensionSpacePoint::fromLegacyDimensionArray($array['dimensionValues'] ?? []),
+            treeNodeId: NodeAggregateId::fromString($array['treeNodeId']),
+            nodeTypeFilter: $array['nodeTypeFilter'] ?? '',
+            allowedNodeTypes: NodeTypeNames::fromStringArray($array['allowedNodeTypes'] ?? []),
+        );
+    }
+}