Merge pull request #25 from Flowpack/task-merge-1.x

TASK: Merge 1.x branch

Author: hlubek

Classes/Core/Infrastructure/ContentReleaseLogger.php

@@ -49,22 +49,22 @@ public static function fromSymfonyOutput(OutputInterface $output, ContentRelease
 
     public function debug($message, array $additionalPayload = [])
     {
-        $this->output->writeln($this->logPrefix . $message . json_encode($additionalPayload));
+        $this->output->writeln($this->logPrefix . 'DEBUG ' . $message . ($additionalPayload ? ' ' . json_encode($additionalPayload) : ''));
     }
 
     public function info($message, array $additionalPayload = [])
     {
-        $this->output->writeln($this->logPrefix . $message . json_encode($additionalPayload));
+        $this->output->writeln($this->logPrefix . 'INFO ' . $message . ($additionalPayload ? ' ' . json_encode($additionalPayload) : ''));
     }
 
     public function warn($message, array $additionalPayload = [])
     {
-        $this->output->writeln($this->logPrefix . $message . json_encode($additionalPayload));
+        $this->output->writeln($this->logPrefix . 'WARN ' . $message . ($additionalPayload ? ' ' . json_encode($additionalPayload) : ''));
     }
 
     public function error($message, array $additionalPayload = [])
     {
-        $this->output->writeln($this->logPrefix . $message . json_encode($additionalPayload));
+        $this->output->writeln($this->logPrefix . 'ERROR ' . $message . ($additionalPayload ? ' ' . json_encode($additionalPayload) : ''));
     }
 
     public function logException(\Exception $exception, string $message, array $additionalPayload)

Classes/NodeEnumeration/Domain/Dto/EnumeratedNode.php

@@ -34,17 +34,24 @@ final class EnumeratedNode implements \JsonSerializable
      */
     protected $arguments;
 
-    private function __construct(string $contextPath, string $nodeIdentifier, array $arguments)
+    /**
+     * The node type name
+     *
+     * @var string
+     */
+    protected $nodeTypeName;
+
+    private function __construct(string $contextPath, string $nodeIdentifier, string $nodeTypeName, array $arguments)
     {
         $this->contextPath = $contextPath;
         $this->nodeIdentifier = $nodeIdentifier;
+        $this->nodeTypeName = $nodeTypeName;
         $this->arguments = $arguments;
     }
 
-
-    static public function fromNode(NodeInterface $node): self
+    static public function fromNode(NodeInterface $node, array $arguments = []): self
     {
-        return new self($node->getContextPath(), $node->getIdentifier(), []);
+        return new self($node->getContextPath(), $node->getIdentifier(), $node->getNodeType()->getName(), $arguments);
     }
 
     static public function fromJsonString(string $enumeratedNodeString): self
@@ -53,14 +60,15 @@ static public function fromJsonString(string $enumeratedNodeString): self
         if (!is_array($tmp)) {
             throw new \Exception('EnumeratedNode cannot be constructed from: ' . $enumeratedNodeString);
         }
-        return new self($tmp['contextPath'], $tmp['nodeIdentifier'], $tmp['arguments']);
+        return new self($tmp['contextPath'], $tmp['nodeIdentifier'], $tmp['nodeTypeName'] ?? '', $tmp['arguments']);
     }
 
     public function jsonSerialize()
     {
         return [
             'contextPath' => $this->contextPath,
             'nodeIdentifier' => $this->nodeIdentifier,
+            'nodeTypeName' => $this->nodeTypeName,
             'arguments' => $this->arguments
         ];
     }
@@ -80,21 +88,23 @@ public function getDimensionsFromContextPath(): array
         return $nodePathAndContext['dimensions'];
     }
 
-    /**
-     * @return string
-     */
     public function getNodeIdentifier(): string
     {
         return $this->nodeIdentifier;
     }
 
+    public function getNodeTypeName(): string
+    {
+        return $this->nodeTypeName;
+    }
+
     public function getArguments(): array
     {
         return $this->arguments;
     }
 
     public function debugString(): string
     {
-        return sprintf('Node %s (%s)', $this->nodeIdentifier, $this->contextPath);
+        return sprintf('%s %s %s(%s)', $this->nodeTypeName, $this->nodeIdentifier, $this->arguments ? http_build_query($this->arguments) . ' ' : '', $this->contextPath);
     }
-}
+}

Classes/NodeEnumeration/NodeEnumerator.php

@@ -66,6 +66,9 @@ public function enumerateAndStoreInRedis(?Site $site, ContentReleaseLogger $cont
             // TODO: EXTENSION POINT HERE, TO ADD ADDITIONAL ENUMERATIONS (.metadata.json f.e.)
             // TODO: not yet fully sure how to handle Enumeration
             $this->redisEnumerationRepository->addDocumentNodesToEnumeration($releaseIdentifier, ...$enumeration);
+            foreach ($enumeration as $enumeratedNode) {
+                $this->emitNodeEnumerated($enumeratedNode, $releaseIdentifier, $contentReleaseLogger);
+            }
         }
     }
 
@@ -119,4 +122,19 @@ private function enumerateAll(?Site $site, ContentReleaseLogger $contentReleaseL
         }
     }
 
+    /**
+     * A node was enumerated for a new content release.
+     *
+     * This signal can be used to add additional EnumeratedNode entries (e.g. with added arguments for pagination or filters) based on the given node.
+     *
+     * @param EnumeratedNode $enumeratedNode
+     * @param ContentReleaseIdentifier $releaseIdentifier
+     * @param ContentReleaseLogger $contentReleaseLogger
+     * @return void
+     * @Flow\Signal
+     */
+    protected function emitNodeEnumerated(EnumeratedNode $enumeratedNode, ContentReleaseIdentifier $releaseIdentifier, ContentReleaseLogger $contentReleaseLogger)
+    {
+    }
+
 }

Classes/NodeRendering/Render/DocumentRenderer.php

@@ -1,5 +1,7 @@
 <?php
+
 namespace Flowpack\DecoupledContentStore\NodeRendering\Render;
+
 use Flowpack\DecoupledContentStore\Aspects\CacheUrlMappingAspect;
 use Flowpack\DecoupledContentStore\Exception;
 use Flowpack\DecoupledContentStore\Core\Infrastructure\ContentReleaseLogger;
@@ -154,7 +156,7 @@ protected function buildControllerContextAndSetBaseUri(string $uri, NodeInterfac
         return new ControllerContext(
             $request,
             new ActionResponse(),
-            new Arguments(array()),
+            new Arguments([]),
             $uriBuilder
         );
     }
@@ -227,7 +229,7 @@ protected function renderDocumentView(NodeInterface $node, $uri, array $requestA
                 );
             }
 
-            $contentReleaseLogger->debug('Rendering document for URI ' . $uri, ['baseUri' => $baseUri]);
+            $contentReleaseLogger->info('Rendering document for URI ' . $uri, ['baseUri' => $baseUri]);
 
             $controllerContext = $this->buildControllerContextAndSetBaseUri($uri, $node, $requestArguments);
             /** @var ActionRequest $request */
@@ -285,18 +287,24 @@ private static function wrapInHttpMessage(string $output, ActionResponse $respon
      * @param NodeInterface $node
      * @param array $arguments
      * @return string The resolved URI for the given node
+     * @throws \Exception
      */
     protected function buildNodeUri(NodeInterface $node, array $arguments)
     {
         /** @var Site $currentSite */
         $currentSite = $node->getContext()->getCurrentSite();
         if (!$currentSite->hasActiveDomains()) {
-            throw new \Exception("No configured domain!");
+            throw new Exception(sprintf("Site %s has no active domain", $currentSite->getNodeName()), 1666684522);
         }
+        $primaryDomain = $currentSite->getPrimaryDomain();
+        if ((string)$primaryDomain->getScheme() === '') {
+            throw new Exception(sprintf("Domain %s for site %s has no scheme defined", $primaryDomain->getHostname(), $currentSite->getNodeName()), 1666684523);
+        }
+
         // HINT: We cannot use a static URL here, but instead need to use an URL of the current site.
         // This is changed from the the old behavior, where we have changed the LinkingService in LinkingServiceAspect,
         // to properly generate the domain part of the routes - and this relies on the proper ControllerContext URI path.
-        $baseControllerContext = $this->buildControllerContextAndSetBaseUri($currentSite->getPrimaryDomain()->__toString(), $node, $arguments);
+        $baseControllerContext = $this->buildControllerContextAndSetBaseUri($primaryDomain->__toString(), $node, $arguments);
         $format = $arguments['@format'] ?? 'html';
         $uri = $this->linkingService->createNodeUri($baseControllerContext, $node, null, $format, true, $arguments, '', false, [], false);
         return $this->removeQueryPartFromUri($uri);

Classes/Utility/GeneratorUtility.php

@@ -5,6 +5,12 @@
 class GeneratorUtility
 {
 
+    /**
+     * @template T
+     * @param iterable<T> $iterable
+     * @param int $chunkSize
+     * @return iterable<array<T>>
+     */
     static public function createArrayBatch(iterable $iterable, int $chunkSize): iterable
     {
         $accumulator = [];
@@ -24,4 +30,4 @@ static public function createArrayBatch(iterable $iterable, int $chunkSize): ite
             yield $accumulator;
         }
     }
-}
+}

README.md

@@ -338,6 +338,64 @@ Flowpack:
 This is needed so that the system knows which keys should be synchronized between the different content stores,
 and what data to delete if a release is removed.
 
+### Rendering additional nodes with arguments (e.g. pagination or filters)
+
+If you render a paginated list or have filters (with a predictable list of values) that can be
+added to a document via arguments, you can implement a slot for the `nodeEnumerated` signal to enumerate additional
+nodes with arguments.
+
+> **Note:** Request arguments must be mapped to URIs via custom routes, since we do not support HTTP query parameters for rendered documents.
+
+#### Example
+
+Add a slot for the `nodeEnumerated` signal via `Package.php`:
+
+```php
+<?php
+class Package extends BasePackage
+{
+    public function boot(Bootstrap $bootstrap)
+    {
+        $dispatcher = $bootstrap->getSignalSlotDispatcher();
+
+        $dispatcher->connect(NodeEnumerator::class, 'nodeEnumerated', MyNodeListsEnumerator::class, 'enumerateNodeLists');
+    }
+}
+```
+
+Implement the slot and enumerate additional nodes depending on the node type:
+
+```php
+<?php
+class NodeListsEnumerator
+{
+    public function enumerateNodeLists(EnumeratedNode $enumeratedNode, ContentReleaseIdentifier $releaseIdentifier, ContentReleaseLogger $logger)
+    {
+        $nodeTypeName = $enumeratedNode->getNodeTypeName();
+        $nodeType = $this->nodeTypeManager->getNodeType($nodeTypeName);
+        if ($nodeType->isOfType('Vendor.Site:Document.Blog.Folder')) {
+            // Get the node and count the number of pages to render
+            // $pageCount = ...
+
+            $pageCount = ceil($postCount / (float)$this->perPage);
+            if ($pageCount <= 1) {
+                return;
+            }
+
+            // Start after the first page, because the first page will be the document without arguments
+            for ($page = 2; $page <= $pageCount; $page++) {
+                $enumeratedNodes[] = EnumeratedNode::fromNode($documentNode, ['page' => $page]);
+            }
+
+            $this->redisEnumerationRepository->addDocumentNodesToEnumeration($releaseIdentifier, ...$enumeratedNodes);
+        }
+    }
+}
+```
+
+The actual logic will depend on your use of the node. Having the actual filtering logic implemented in PHP is
+beneficial, because it allows you to use it in the rendering process as well as in the additional enumeration.
+
 ### Extending the backend module
 
 - You need a Views.yaml in your package, looking like this:

composer.json

@@ -1,6 +1,7 @@
 {
-  "description": "",
+  "description": "This is the 2nd generation of a Two-Stack CMS package for Neos.",
   "type": "neos-package",
+  "license": "GPL-3.0-or-later",
   "name": "flowpack/decoupledcontentstore",
   "require": {
     "php": "^7.4 || ^8.0",