TASK: Cleanup usage of NodeTypeConstraintsWithSubNodeTypes

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

@@ -18,6 +18,7 @@
 use Neos\ContentRepository\Core\DimensionSpace\DimensionSpacePoint;
 use Neos\ContentRepository\Core\DimensionSpace\DimensionSpacePointSet;
 use Neos\ContentRepository\Core\DimensionSpace\Exception\DimensionSpacePointNotFound;
+use Neos\ContentRepository\Core\NodeType\ConstraintCheck;
 use Neos\ContentRepository\Core\SharedModel\Exception\RootNodeAggregateDoesNotExist;
 use Neos\ContentRepository\Core\SharedModel\Exception\ContentStreamDoesNotExistYet;
 use Neos\ContentRepository\Core\SharedModel\Exception\DimensionSpacePointIsNotYetOccupied;
@@ -216,18 +217,15 @@ protected function requireNodeTypeToAllowNodesOfTypeInReference(
         if (is_null($propertyDeclaration)) {
             throw ReferenceCannotBeSet::becauseTheNodeTypeDoesNotDeclareIt($referenceName, $nodeTypeName);
         }
-        if (isset($propertyDeclaration['constraints']['nodeTypes'])) {
-            $nodeTypeConstraints = NodeTypeConstraintsWithSubNodeTypes::createFromNodeTypeDeclaration(
-                $propertyDeclaration['constraints']['nodeTypes'],
-                $this->getNodeTypeManager()
+
+        $constraints = $propertyDeclaration['constraints']['nodeTypes'] ?? [];
+
+        if (!ConstraintCheck::create($constraints)->isNodeTypeAllowed($nodeType)) {
+            throw ReferenceCannotBeSet::becauseTheConstraintsAreNotMatched(
+                $referenceName,
+                $nodeTypeName,
+                $nodeTypeNameInQuestion
             );
-            if (!$nodeTypeConstraints->matches($nodeTypeNameInQuestion)) {
-                throw ReferenceCannotBeSet::becauseTheConstraintsAreNotMatched(
-                    $referenceName,
-                    $nodeTypeName,
-                    $nodeTypeNameInQuestion
-                );
-            }
         }
     }
 

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

@@ -6,16 +6,24 @@
  * Performs node type constraint checks against a given set of constraints
  * @internal
  */
-class ConstraintCheck
+final readonly class ConstraintCheck
 {
     /**
-     * @param array<string,mixed> $constraints
+     * @param array<string,bool> $constraints
      */
-    public function __construct(
-        private readonly array $constraints
+    private function __construct(
+        private array $constraints
     ) {
     }
 
+    /**
+     * @param array<string,bool> $constraints
+     */
+    public static function create(array $constraints): self
+    {
+        return new self($constraints);
+    }
+
     public function isNodeTypeAllowed(NodeType $nodeType): bool
     {
         $directConstraintsResult = $this->isNodeTypeAllowedByDirectConstraints($nodeType);

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

@@ -479,7 +479,7 @@ public function getNodeTypeNameOfTetheredNode(NodeName $nodeName): NodeTypeName
     public function allowsChildNodeType(NodeType $nodeType): bool
     {
         $constraints = $this->getConfiguration('constraints.nodeTypes') ?: [];
-        return (new ConstraintCheck($constraints))->isNodeTypeAllowed($nodeType);
+        return ConstraintCheck::create($constraints)->isNodeTypeAllowed($nodeType);
     }
 
     /**

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

@@ -260,7 +260,7 @@ public function isNodeTypeAllowedAsChildToTetheredNode(NodeType $parentNodeType,
 
         $constraints = Arrays::arrayMergeRecursiveOverrule($constraints, $childNodeConstraintConfiguration);
 
-        return (new ConstraintCheck($constraints))->isNodeTypeAllowed($nodeType);
+        return ConstraintCheck::create($constraints)->isNodeTypeAllowed($nodeType);
     }
 
     /**

Neos.ContentRepository.Core/Classes/Projection/ContentGraph/NodeTypeConstraintsWithSubNodeTypes.php

@@ -33,50 +33,6 @@ private function __construct(
     ) {
     }
 
-    /**
-     * @param array<string,bool> $nodeTypeDeclaration
-     */
-    public static function createFromNodeTypeDeclaration(
-        array $nodeTypeDeclaration,
-        NodeTypeManager $nodeTypeManager
-    ): self {
-        $wildCardAllowed = false;
-        $explicitlyAllowedNodeTypeNames = [];
-        $explicitlyDisallowedNodeTypeNames = [];
-        foreach ($nodeTypeDeclaration as $constraintName => $allowed) {
-            if ($constraintName === '*') {
-                $wildCardAllowed = $allowed;
-            } else {
-                if ($allowed) {
-                    $explicitlyAllowedNodeTypeNames[] = $constraintName;
-                } else {
-                    $explicitlyDisallowedNodeTypeNames[] = $constraintName;
-                }
-            }
-        }
-
-        return new self(
-            $wildCardAllowed,
-            self::expandByIncludingSubNodeTypes(
-                NodeTypeNames::fromStringArray($explicitlyAllowedNodeTypeNames),
-                $nodeTypeManager
-            ),
-            self::expandByIncludingSubNodeTypes(
-                NodeTypeNames::fromStringArray($explicitlyDisallowedNodeTypeNames),
-                $nodeTypeManager
-            )
-        );
-    }
-
-    public static function allowAll(): self
-    {
-        return new self(
-            true,
-            NodeTypeNames::createEmpty(),
-            NodeTypeNames::createEmpty(),
-        );
-    }
-
     public static function create(NodeTypeConstraints $nodeTypeConstraints, NodeTypeManager $nodeTypeManager): self
     {
         // in case there are no filters, we fall back to allowing every node type.
@@ -137,22 +93,4 @@ public function matches(NodeTypeName $nodeTypeName): bool
         // otherwise, we return $wildcardAllowed.
         return $this->isWildCardAllowed;
     }
-
-    public function toFilterString(): string
-    {
-        $parts = [];
-        if ($this->isWildCardAllowed) {
-            $parts[] = '*';
-        }
-
-        foreach ($this->explicitlyDisallowedNodeTypeNames as $nodeTypeName) {
-            $parts[] = '!' . $nodeTypeName->value;
-        }
-
-        foreach ($this->explicitlyAllowedNodeTypeNames as $nodeTypeName) {
-            $parts[] = $nodeTypeName->value;
-        }
-
-        return implode(',', $parts);
-    }
 }