WIP: FEATURE: Overhaul NodeTypeManager

Neos.ContentRepository.BehavioralTests/Classes/TestSuite/Behavior/GherkinPyStringNodeBasedNodeTypeManagerFactory.php

@@ -15,6 +15,7 @@
 namespace Neos\ContentRepository\BehavioralTests\TestSuite\Behavior;
 
 use Behat\Gherkin\Node\PyStringNode;
+use Neos\ContentRepository\Core\NodeType\ClosureNodeTypeProvider;
 use Neos\ContentRepository\Core\NodeType\NodeLabelGeneratorFactoryInterface;
 use Neos\ContentRepository\Core\NodeType\NodeLabelGeneratorInterface;
 use Neos\ContentRepository\Core\NodeType\NodeType;
@@ -45,18 +46,9 @@ public function build(ContentRepositoryId $contentRepositoryId, array $options):
     public static function initializeWithPyStringNode(PyStringNode $nodeTypesToUse): void
     {
         self::$nodeTypesToUse = new NodeTypeManager(
-            fn (): array => Yaml::parse($nodeTypesToUse->getRaw()) ?? [],
-            new class implements NodeLabelGeneratorFactoryInterface {
-                public function create(NodeType $nodeType): NodeLabelGeneratorInterface
-                {
-                    return new class implements NodeLabelGeneratorInterface {
-                        public function getLabel(Node $node): string
-                        {
-                            return $node->nodeTypeName->value;
-                        }
-                    };
-                }
-            }
+            new ClosureNodeTypeProvider(
+                fn (): array => Yaml::parse($nodeTypesToUse->getRaw()) ?? [],
+            )
         );
     }
 

Neos.ContentRepository.BehavioralTests/Tests/Functional/Feature/WorkspacePublication/WorkspaceWritingDuringPublication.php

@@ -31,7 +31,7 @@
 use Neos\ContentRepository\Core\Feature\WorkspaceCreation\Command\CreateRootWorkspace;
 use Neos\ContentRepository\Core\Feature\WorkspaceCreation\Command\CreateWorkspace;
 use Neos\ContentRepository\Core\Feature\WorkspaceRebase\Command\RebaseWorkspace;
-use Neos\ContentRepository\Core\NodeType\DefaultNodeLabelGeneratorFactory;
+use Neos\ContentRepository\Core\NodeType\ClosureNodeTypeProvider;
 use Neos\ContentRepository\Core\NodeType\NodeTypeManager;
 use Neos\ContentRepository\Core\NodeType\NodeTypeName;
 use Neos\ContentRepository\Core\SharedModel\ContentRepository\ContentRepositoryId;
@@ -81,17 +81,18 @@ public function getContentDimensionsOrderedByPriority(): array
         };
 
         GherkinPyStringNodeBasedNodeTypeManagerFactory::$nodeTypesToUse = new NodeTypeManager(
-            fn (): array => [
-                'Neos.ContentRepository:Root' => [],
-                'Neos.ContentRepository.Testing:Document' => [
-                    'properties' => [
-                        'title' => [
-                            'type' => 'string'
+            new ClosureNodeTypeProvider(
+                fn (): array => [
+                    'Neos.ContentRepository:Root' => [],
+                    'Neos.ContentRepository.Testing:Document' => [
+                        'properties' => [
+                            'title' => [
+                                'type' => 'string'
+                            ]
                         ]
                     ]
-                ]
-            ],
-            new DefaultNodeLabelGeneratorFactory()
+                ],
+            )
         );
         $this->contentRepositoryRegistry = $this->objectManager->get(ContentRepositoryRegistry::class);
 

Neos.ContentRepository.Core/Classes/Feature/Common/ConstraintChecks.php

@@ -23,7 +23,6 @@
 use Neos\ContentRepository\Core\Feature\NodeReferencing\Dto\SerializedNodeReferences;
 use Neos\ContentRepository\Core\Feature\NodeVariation\Exception\DimensionSpacePointIsAlreadyOccupied;
 use Neos\ContentRepository\Core\Infrastructure\Property\PropertyType;
-use Neos\ContentRepository\Core\NodeType\ConstraintCheck;
 use Neos\ContentRepository\Core\NodeType\NodeType;
 use Neos\ContentRepository\Core\NodeType\NodeTypeManager;
 use Neos\ContentRepository\Core\NodeType\NodeTypeName;
@@ -61,6 +60,7 @@
 use Neos\EventStore\Model\EventStream\ExpectedVersion;
 
 /**
+ * TODO Remove
  * @internal implementation details of command handlers
  */
 trait ConstraintChecks
@@ -209,10 +209,9 @@ protected function requireNodeTypeToDeclareProperty(NodeTypeName $nodeTypeName,
     protected function requireNodeTypeToDeclareReference(NodeTypeName $nodeTypeName, ReferenceName $referenceName): void
     {
         $nodeType = $this->requireNodeType($nodeTypeName);
-        if ($nodeType->hasReference($referenceName->value)) {
-            return;
+        if (!$nodeType->referenceDefinitions->contain($referenceName)) {
+            throw ReferenceCannotBeSet::becauseTheNodeTypeDoesNotDeclareIt($referenceName, $nodeTypeName);
         }
-        throw ReferenceCannotBeSet::becauseTheNodeTypeDoesNotDeclareIt($referenceName, $nodeTypeName);
     }
 
     protected function requireNodeTypeToAllowNodesOfTypeInReference(
@@ -221,9 +220,14 @@ protected function requireNodeTypeToAllowNodesOfTypeInReference(
         NodeTypeName $nodeTypeNameInQuestion
     ): void {
         $nodeType = $this->requireNodeType($nodeTypeName);
-        $constraints = $nodeType->getReferences()[$referenceName->value]['constraints']['nodeTypes'] ?? [];
-
-        if (!ConstraintCheck::create($constraints)->isNodeTypeAllowed($this->requireNodeType($nodeTypeNameInQuestion))) {
+        $referenceDefinition = $nodeType->referenceDefinitions->get($referenceName);
+        if ($referenceDefinition === null) {
+            throw ReferenceCannotBeSet::becauseTheNodeTypeDoesNotDeclareIt(
+                $referenceName,
+                $nodeTypeName,
+            );
+        }
+        if (!$referenceDefinition->nodeTypeConstraints->isNodeTypeAllowed($nodeTypeNameInQuestion)) {
             throw ReferenceCannotBeSet::becauseTheNodeTypeConstraintsAreNotMatched(
                 $referenceName,
                 $nodeTypeName,
@@ -235,8 +239,15 @@ protected function requireNodeTypeToAllowNodesOfTypeInReference(
     protected function requireNodeTypeToAllowNumberOfReferencesInReference(SerializedNodeReferences $nodeReferences, ReferenceName $referenceName, NodeTypeName $nodeTypeName): void
     {
         $nodeType = $this->requireNodeType($nodeTypeName);
+        $referenceDefinition = $nodeType->referenceDefinitions->get($referenceName);
+        if ($referenceDefinition === null) {
+            throw ReferenceCannotBeSet::becauseTheNodeTypeDoesNotDeclareIt(
+                $referenceName,
+                $nodeTypeName,
+            );
+        }
 
-        $maxItems = $nodeType->getReferences()[$referenceName->value]['constraints']['maxItems'] ?? null;
+        $maxItems = $referenceDefinition->maxItems ?? null;
         if ($maxItems === null) {
             return;
         }

Neos.ContentRepository.Core/Classes/Feature/NodeModification/Dto/PropertyScope.php

@@ -60,6 +60,7 @@ public function resolveAffectedOrigins(
         };
     }
 
+    // TODO remove
     public static function tryFromDeclaration(NodeType $nodeType, PropertyName $propertyName): self
     {
         $declaration = $nodeType->getProperties()[$propertyName->value]['scope'] ?? null;

Neos.ContentRepository.Core/Classes/Feature/NodeModification/Dto/SerializedPropertyValues.php

@@ -71,29 +71,25 @@ public static function fromArray(array $propertyValues): self
     public static function defaultFromNodeType(NodeType $nodeType, PropertyConverter $propertyConverter): self
     {
         $values = [];
-        foreach ($nodeType->getDefaultValuesForProperties() as $propertyName => $defaultValue) {
+        foreach ($nodeType->propertyDefinitions as $propertyDefinition) {
             $propertyType = PropertyType::fromNodeTypeDeclaration(
-                $nodeType->getPropertyType($propertyName),
-                PropertyName::fromString($propertyName),
+                $nodeType->getPropertyType($propertyDefinition->name->value),
+                PropertyName::fromString($propertyDefinition->name->value),
                 $nodeType->name
             );
             $deserializedDefaultValue = $propertyConverter->deserializePropertyValue(
-                SerializedPropertyValue::create($defaultValue, $propertyType->getSerializationType())
+                SerializedPropertyValue::create($propertyDefinition->defaultValue, $propertyType->getSerializationType())
             );
             // The $defaultValue and $properlySerializedDefaultValue will likely equal, but in some cases diverge.
             // For example relative date time default values like "now" will herby be serialized to the current date.
             // Also, custom value objects might serialize slightly different, but more "correct"
             // (by for example adding default values for undeclared properties)
             // Additionally due the double conversion, we guarantee that a valid property converted exists at this time.
             $properlySerializedDefaultValue = $propertyConverter->serializePropertyValue(
-                PropertyType::fromNodeTypeDeclaration(
-                    $nodeType->getPropertyType($propertyName),
-                    PropertyName::fromString($propertyName),
-                    $nodeType->name
-                ),
+                $propertyType,
                 $deserializedDefaultValue
             );
-            $values[$propertyName] = $properlySerializedDefaultValue;
+            $values[$propertyDefinition->name->value] = $properlySerializedDefaultValue;
         }
 
         return new self($values);

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

@@ -0,0 +1,156 @@
+<?php
+
+/*
+ * This file is part of the Neos.ContentRepository 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\ContentRepository\Core\NodeType;
+
+use Neos\ContentRepository\Core\SharedModel\Exception\NodeConfigurationException;
+use Neos\ContentRepository\Core\SharedModel\Exception\NodeTypeIsFinalException;
+use Neos\ContentRepository\Core\SharedModel\Exception\NodeTypeNotFoundException;
+
+/**
+ * @internal
+ */
+final class ClosureNodeTypeProvider implements NodeTypeProviderInterface
+{
+    private NodeTypes $cachedNodeTypes;
+
+    public function __construct(
+        private readonly \Closure $nodeTypeConfigLoader,
+    ) {
+        $this->cachedNodeTypes = NodeTypes::fromArray([]);
+    }
+
+    public function getNodeTypes(): NodeTypes
+    {
+        if ($this->cachedNodeTypes->isEmpty()) {
+            $completeNodeTypeConfiguration = ($this->nodeTypeConfigLoader)();
+            // the root node type must always exist
+            $completeNodeTypeConfiguration[NodeTypeName::ROOT_NODE_TYPE_NAME] ??= [];
+            foreach (array_keys($completeNodeTypeConfiguration) as $nodeTypeName) {
+                if (!is_string($nodeTypeName)) {
+                    continue;
+                }
+                if (!is_array($completeNodeTypeConfiguration[$nodeTypeName])) {
+                    continue;
+                }
+                $this->loadNodeType($nodeTypeName, $completeNodeTypeConfiguration);
+            }
+        }
+        return $this->cachedNodeTypes;
+    }
+
+    /**
+     * Load one node type, if it is not loaded yet.
+     *
+     * @param array<string,mixed> $completeNodeTypeConfiguration the full node type configuration for all node types
+     * @throws NodeConfigurationException
+     * @throws NodeTypeIsFinalException
+     * @throws NodeTypeNotFoundException
+     */
+    private function loadNodeType(string $nodeTypeName, array &$completeNodeTypeConfiguration): NodeType
+    {
+        $cachedNodeType = $this->cachedNodeTypes->get($nodeTypeName);
+        if ($cachedNodeType !== null) {
+            return $cachedNodeType;
+        }
+
+        if (!isset($completeNodeTypeConfiguration[$nodeTypeName])) {
+            throw new NodeTypeNotFoundException('Node type "' . $nodeTypeName . '" does not exist', 1316451800);
+        }
+
+        $nodeTypeConfiguration = $completeNodeTypeConfiguration[$nodeTypeName];
+        try {
+            $superTypes = isset($nodeTypeConfiguration['superTypes'])
+                ? $this->evaluateSuperTypesConfiguration(
+                    $nodeTypeConfiguration['superTypes'],
+                    $completeNodeTypeConfiguration
+                )
+                : [];
+        } catch (NodeConfigurationException $exception) {
+            throw new NodeConfigurationException('Node type "' . $nodeTypeName . '" sets super type with a non-string key to NULL.', 1416578395, $exception);
+        } catch (NodeTypeIsFinalException $exception) {
+            throw new NodeTypeIsFinalException('Node type "' . $nodeTypeName . '" has a super type "' . $exception->getMessage() . '" which is final.', 1316452423, $exception);
+        }
+
+        // Remove unset properties
+        $nodeTypeConfiguration['properties'] = array_filter($nodeTypeConfiguration['properties'] ?? [], static fn ($propertyConfiguration) => $propertyConfiguration !== null);
+        if ($nodeTypeConfiguration['properties'] === []) {
+            unset($nodeTypeConfiguration['properties']);
+        }
+
+        $nodeType = new NodeType(
+            NodeTypeName::fromString($nodeTypeName),
+            $superTypes,
+            $nodeTypeConfiguration,
+            $this->nodeLabelGeneratorFactory
+        );
+
+        $this->cachedNodeTypes = $this->cachedNodeTypes->with($nodeType);
+        return $nodeType;
+    }
+
+    /**
+     * Evaluates the given superTypes configuation and returns the array of effective superTypes.
+     *
+     * @param array<string,mixed> $superTypesConfiguration
+     * @param array<string,mixed> $completeNodeTypeConfiguration
+     * @return array<string,NodeType|null>
+     */
+    private function evaluateSuperTypesConfiguration(
+        array $superTypesConfiguration,
+        array $completeNodeTypeConfiguration
+    ): array {
+        $superTypes = [];
+        foreach ($superTypesConfiguration as $superTypeName => $enabled) {
+            if (!is_string($superTypeName)) {
+                throw new NodeConfigurationException(
+                    'superTypes must be a dictionary; the array format was deprecated since Neos 2.0',
+                    1651821391
+                );
+            }
+            $superTypes[$superTypeName] = $this->evaluateSuperTypeConfiguration(
+                $superTypeName,
+                $enabled,
+                $completeNodeTypeConfiguration
+            );
+        }
+
+        return $superTypes;
+    }
+
+    /**
+     * Evaluates a single superType configuration and returns the NodeType if enabled.
+     *
+     * @param array<string,mixed> $completeNodeTypeConfiguration
+     * @throws NodeConfigurationException
+     * @throws NodeTypeIsFinalException
+     */
+    private function evaluateSuperTypeConfiguration(
+        string $superTypeName,
+        ?bool $enabled,
+        array &$completeNodeTypeConfiguration
+    ): ?NodeType {
+        // Skip unset node types
+        if ($enabled === false || $enabled === null) {
+            return null;
+        }
+
+        $superType = $this->loadNodeType($superTypeName, $completeNodeTypeConfiguration);
+        if ($superType->isFinal() === true) {
+            throw new NodeTypeIsFinalException($superType->name->value, 1444944148);
+        }
+
+        return $superType;
+    }
+}

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

@@ -5,6 +5,7 @@
 /**
  * Performs node type constraint checks against a given set of constraints
  * @internal
+ * TODO replace with {@see NodeTypeConstraints}
  */
 final readonly class ConstraintCheck
 {