Merge pull request #17 from Flowpack/feature-enumerated-node-signal

FEATURE: Add signal for enumerated node for enumerating additional nodes with arguments

Author: skurfuerst

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

@@ -67,11 +67,14 @@ 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);
+            }
         }
     }
 
     /**
-     * @param Site $site
+     * @param Site|null $site
      * @param ContentReleaseLogger $contentReleaseLogger
      * @return iterable<EnumeratedNode>
      */
@@ -97,12 +100,13 @@ private function enumerateAll(?Site $site, ContentReleaseLogger $contentReleaseL
                     $contextPath = $documentNode->getContextPath();
 
                     if ($nodeTypeWhitelist->matches(NodeTypeName::fromString($documentNode->getNodeType()->getName()))) {
+                        $enumeratedNode = EnumeratedNode::fromNode($documentNode);
 
                         $contentReleaseLogger->debug('Registering node for publishing', [
-                            'node' => $contextPath
+                            'enumeratedNode' => $enumeratedNode->debugString()
                         ]);
 
-                        yield EnumeratedNode::fromNode($documentNode);
+                        yield $enumeratedNode;
                     } else {
                         $contentReleaseLogger->debug('Skipping node from publishing, because it did not match the configured nodeTypeWhitelist', [
                             'node' => $contextPath,
@@ -123,4 +127,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 */

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: