FrontendTypoScriptFactory.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\TypoScript;
 
use Psr\Container\ContainerInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
use ‪TYPO3\CMS\Core\Site\Entity\SiteInterface;
use ‪TYPO3\CMS\Core\TypoScript\AST\Merger\SetupConfigMerger;
use ‪TYPO3\CMS\Core\TypoScript\AST\Node\ChildNode;
use ‪TYPO3\CMS\Core\TypoScript\AST\Node\RootNode;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\IncludeNode\RootInclude;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\SysTemplateTreeBuilder;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\Traverser\ConditionVerdictAwareIncludeTreeTraverser;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\Traverser\IncludeTreeTraverser;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\Visitor\IncludeTreeAstBuilderVisitor;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\Visitor\IncludeTreeConditionIncludeListAccumulatorVisitor;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\Visitor\IncludeTreeConditionMatcherVisitor;
use ‪TYPO3\CMS\Core\TypoScript\IncludeTree\Visitor\IncludeTreeSetupConditionConstantSubstitutionVisitor;
use ‪TYPO3\CMS\Core\TypoScript\Tokenizer\LossyTokenizer;
use ‪TYPO3\CMS\Frontend\Event\ModifyTypoScriptConfigEvent;
use ‪TYPO3\CMS\Frontend\Event\ModifyTypoScriptConstantsEvent;
 
final readonly class FrontendTypoScriptFactory
{
    public function __construct(
        private ContainerInterface $container,
        private EventDispatcherInterface $eventDispatcher,
        private SysTemplateTreeBuilder $treeBuilder,
        private LossyTokenizer $tokenizer,
        private IncludeTreeTraverser $includeTreeTraverser,
        private ConditionVerdictAwareIncludeTreeTraverser $includeTreeTraverserConditionVerdictAware,
    ) {}
 
    public function createSettingsAndSetupConditions(
        SiteInterface $site,
        array $sysTemplateRows,
        array $expressionMatcherVariables,
        ?PhpFrontend $typoScriptCache,
    ): FrontendTypoScript {
        $settingsDetails = $this->createSettings(
            $site,
            $sysTemplateRows,
            $expressionMatcherVariables,
            $typoScriptCache
        );
        $setupDetails = $this->createSetupConditionList(
            $site,
            $sysTemplateRows,
            $expressionMatcherVariables,
            $typoScriptCache,
            $settingsDetails['flatSettings'],
            $settingsDetails['settingsConditionList'],
        );
        $frontendTypoScript = new FrontendTypoScript(
            $settingsDetails['settingsTree'],
            $settingsDetails['settingsConditionList'],
            $settingsDetails['flatSettings'],
            $setupDetails['setupConditionList'],
        );
        if ($setupDetails['setupIncludeTree']) {
            $frontendTypoScript->setSetupIncludeTree($setupDetails['setupIncludeTree']);
        }
        return $frontendTypoScript;
    }
 
    private function createSettings(
        SiteInterface $site,
        array $sysTemplateRows,
        array $expressionMatcherVariables,
        ?PhpFrontend $typoScriptCache,
    ): array {
        $conditionTreeCacheIdentifier = 'settings-condition-tree-' . hash('xxh3', json_encode($sysTemplateRows, JSON_THROW_ON_ERROR));
 
        if ($conditionTree = $typoScriptCache?->require($conditionTreeCacheIdentifier)) {
            // Got the (flat) include tree of all settings conditions for this TypoScript combination from cache.
            // Good. Traverse this list to calculate "current" condition verdicts. Hash this list together with a
            // hash of the TypoScript sys_templates, and try to retrieve the full settings TypoScript AST from cache.
            // Note: Working with the derived condition tree that *only* contains conditions, but not the full
            // include tree is a trick: We only need the condition verdicts to know the AST cache identifier,
            // and traversing the flat condition tree is quicker than traversing the entire settings include tree,
            // since it only scales with the number of settings conditions and not with the full amount of TypoScript
            // settings. The same trick is used for the setup AST cache later.
            $conditionMatcherVisitor = $this->container->get(IncludeTreeConditionMatcherVisitor::class);
            $conditionMatcherVisitor->initializeExpressionMatcherWithVariables($expressionMatcherVariables);
            // It does not matter if we use IncludeTreeTraverser or ConditionVerdictAwareIncludeTreeTraverser here:
            // Conditions list is flat, not nested. IncludeTreeTraverser has an if() less, so we use that one.
            $this->includeTreeTraverser->traverse($conditionTree, [$conditionMatcherVisitor]);
            $conditionList = $conditionMatcherVisitor->getConditionListWithVerdicts();
            $settings = $typoScriptCache->require(
                'settings-' . hash('xxh3', $conditionTreeCacheIdentifier . json_encode($conditionList, JSON_THROW_ON_ERROR))
            );
            if (is_array($settings)) {
                return [
                    'settingsTree' => $settings['ast'],
                    'flatSettings' => $settings['flatSettings'],
                    'settingsConditionList' => $conditionList,
                ];
            }
        }
 
        // We did not get settings from cache, or are not allowed to use cache. Build settings from scratch.
        // We fetch the full settings include tree (from cache if possible), register the condition
        // matcher and register the AST builder and traverse include tree to retrieve settings AST and derive
        // 'flat settings' from it. Both are cached if allowed afterward for the above 'if' to kick in next time.
        $includeTree = $this->treeBuilder->getTreeBySysTemplateRowsAndSite('constants', $sysTemplateRows, $this->tokenizer, $site, $typoScriptCache);
        $conditionMatcherVisitor = $this->container->get(IncludeTreeConditionMatcherVisitor::class);
        $conditionMatcherVisitor->initializeExpressionMatcherWithVariables($expressionMatcherVariables);
        $visitors = [];
        $visitors[] = $conditionMatcherVisitor;
        $astBuilderVisitor = $this->container->get(IncludeTreeAstBuilderVisitor::class);
        $visitors[] = $astBuilderVisitor;
        // We must use ConditionVerdictAwareIncludeTreeTraverser here: This one does not walk into
        // children for not matching conditions, which is important to create the correct AST.
        $this->includeTreeTraverserConditionVerdictAware->traverse($includeTree, $visitors);
        $tree = $astBuilderVisitor->getAst();
        // @internal Dispatch an experimental event allowing listeners to still change the settings AST,
        //           to for instance implement nested constants if really needed. Note this event may change
        //           or vanish later without further notice.
        $tree = $this->eventDispatcher->dispatch(new ModifyTypoScriptConstantsEvent($tree))->getConstantsAst();
        $flatSettings = $tree->flatten();
 
        // Prepare the full list of settings conditions in order to cache this list, avoiding the
        // settings AST building next time. We need all conditions of the entire include tree, but the
        // above ConditionVerdictAwareIncludeTreeTraverser did not find nested conditions if an upper
        // condition did not match. We thus have to traverse include tree a second time with the
        // IncludeTreeTraverser. This one does traverse into not matching conditions.
        $visitors = [];
        $conditionMatcherVisitor = $this->container->get(IncludeTreeConditionMatcherVisitor::class);
        $conditionMatcherVisitor->initializeExpressionMatcherWithVariables($expressionMatcherVariables);
        $visitors[] = $conditionMatcherVisitor;
        $conditionTreeAccumulatorVisitor = null;
        if (!$conditionTree && $typoScriptCache) {
            // If the settingsConditionTree did not come from cache above and if we are allowed to cache,
            // register the visitor that creates the settings condition include tree, to cache it.
            $conditionTreeAccumulatorVisitor = $this->container->get(IncludeTreeConditionIncludeListAccumulatorVisitor::class);
            $visitors[] = $conditionTreeAccumulatorVisitor;
        }
        $this->includeTreeTraverser->traverse($includeTree, $visitors);
        $conditionList = $conditionMatcherVisitor->getConditionListWithVerdicts();
 
        if ($conditionTreeAccumulatorVisitor) {
            // Cache the flat condition include tree for next run.
            $conditionTree = $conditionTreeAccumulatorVisitor->getConditionIncludes();
            $typoScriptCache?->set(
                $conditionTreeCacheIdentifier,
                'return unserialize(\'' . addcslashes(serialize($conditionTree), '\'\\') . '\');'
            );
        }
        $typoScriptCache?->set(
            // Cache full AST and the derived 'flattened' variant for next run, which will kick in if
            // the sys_templates and condition verdicts are identical with another Request.
            'settings-' . hash('xxh3', $conditionTreeCacheIdentifier . json_encode($conditionList, JSON_THROW_ON_ERROR)),
            'return unserialize(\'' . addcslashes(serialize(['ast' => $tree, 'flatSettings' => $flatSettings]), '\'\\') . '\');'
        );
 
        return [
            'settingsTree' => $tree,
            'flatSettings' => $flatSettings,
            'settingsConditionList' => $conditionList,
        ];
    }
 
    private function createSetupConditionList(
        SiteInterface $site,
        array $sysTemplateRows,
        array $expressionMatcherVariables,
        ?PhpFrontend $typoScriptCache,
        array $flatSettings,
        array $settingsConditionList,
    ): array {
        $conditionTreeCacheIdentifier = 'setup-condition-tree-'
            . hash('xxh3', json_encode($sysTemplateRows, JSON_THROW_ON_ERROR) . json_encode($settingsConditionList, JSON_THROW_ON_ERROR));
 
        if ($conditionTree = $typoScriptCache?->require($conditionTreeCacheIdentifier)) {
            // We got the flat list of all setup conditions for this TypoScript combination from cache. Good. We traverse
            // this list to calculate "current" condition verdicts, which we need as hash to be part of page cache identifier.
            // We're done and return. Note 'setupIncludeTree' is *not* returned in this case since it is not needed and
            // may or may not be needed later, depending on if we can get a page cache entry later and if it has _INT objects.
            $visitors = [];
            $conditionConstantSubstitutionVisitor = $this->container->get(IncludeTreeSetupConditionConstantSubstitutionVisitor::class);
            $conditionConstantSubstitutionVisitor->setFlattenedConstants($flatSettings);
            $visitors[] = $conditionConstantSubstitutionVisitor;
            $conditionMatcherVisitor = $this->container->get(IncludeTreeConditionMatcherVisitor::class);
            $conditionMatcherVisitor->initializeExpressionMatcherWithVariables($expressionMatcherVariables);
            $visitors[] = $conditionMatcherVisitor;
            // It does not matter if we use IncludeTreeTraverser or ConditionVerdictAwareIncludeTreeTraverser here:
            // Condition list is flat, not nested. IncludeTreeTraverser has an if() less, so we use that one.
            $this->includeTreeTraverser->traverse($conditionTree, $visitors);
            return [
                'setupConditionList' => $conditionMatcherVisitor->getConditionListWithVerdicts(),
                'setupIncludeTree' => null,
            ];
        }
 
        // We did not get setup condition list from cache, or are not allowed to use cache. We have to build setup
        // condition list from scratch. This means we'll fetch the full setup include tree (from cache if possible),
        // register the constant substitution visitor, the condition matcher and the condition accumulator visitor.
        $includeTree = $this->treeBuilder->getTreeBySysTemplateRowsAndSite('setup', $sysTemplateRows, $this->tokenizer, $site, $typoScriptCache);
        $visitors = [];
        $conditionConstantSubstitutionVisitor = $this->container->get(IncludeTreeSetupConditionConstantSubstitutionVisitor::class);
        $conditionConstantSubstitutionVisitor->setFlattenedConstants($flatSettings);
        $visitors[] = $conditionConstantSubstitutionVisitor;
        $conditionMatcherVisitor = $this->container->get(IncludeTreeConditionMatcherVisitor::class);
        $conditionMatcherVisitor->initializeExpressionMatcherWithVariables($expressionMatcherVariables);
        $visitors[] = $conditionMatcherVisitor;
        $conditionTreeAccumulatorVisitor = $this->container->get(IncludeTreeConditionIncludeListAccumulatorVisitor::class);
        $visitors[] = $conditionTreeAccumulatorVisitor;
        // It is important to use IncludeTreeTraverser here: We need the condition verdicts of *all* conditions, and
        // we want to accumulate all of them. The ConditionVerdictAwareIncludeTreeTraverser wouldn't walk into nested
        // conditions if an upper one does not match, which defeats cache identifier calculations.
        $this->includeTreeTraverser->traverse($includeTree, $visitors);
 
        $typoScriptCache?->set(
            $conditionTreeCacheIdentifier,
            'return unserialize(\'' . addcslashes(serialize($conditionTreeAccumulatorVisitor->getConditionIncludes()), '\'\\') . '\');'
        );
 
        return [
            'setupConditionList' => $conditionMatcherVisitor->getConditionListWithVerdicts(),
            'setupIncludeTree' => $includeTree,
        ];
    }
 
    public function createSetupConfigOrFullSetup(
        bool $needsFullSetup,
        FrontendTypoScript $frontendTypoScript,
        SiteInterface $site,
        array $sysTemplateRows,
        array $expressionMatcherVariables,
        string $type,
        ?PhpFrontend $typoScriptCache,
        ?ServerRequestInterface $request,
    ): FrontendTypoScript {
        $setupTypoScriptCacheIdentifier = 'setup-' . hash(
            'xxh3',
            json_encode($sysTemplateRows, JSON_THROW_ON_ERROR)
            . json_encode($frontendTypoScript->getSettingsConditionList(), JSON_THROW_ON_ERROR)
            . json_encode($frontendTypoScript->getSetupConditionList(), JSON_THROW_ON_ERROR)
        );
        $setupConfigTypoScriptCacheIdentifier = 'setup-config-' . hash('xxh3', $setupTypoScriptCacheIdentifier . $type);
 
        $gotSetupConfigFromCache = false;
        if ($setupConfigTypoScriptCache = $typoScriptCache?->require($setupConfigTypoScriptCacheIdentifier)) {
            $frontendTypoScript->setConfigTree($setupConfigTypoScriptCache['ast']);
            $frontendTypoScript->setConfigArray($setupConfigTypoScriptCache['array']);
            if (!$needsFullSetup) {
                // Fully cached page context without _INT - only 'config' is needed. Return early.
                return $frontendTypoScript;
            }
            $gotSetupConfigFromCache = true;
        }
 
        $setupRawConfigAst = null;
        if (!$typoScriptCache || $needsFullSetup || !$gotSetupConfigFromCache) {
            // If caching is not allowed, if no page cache entry could be loaded or if the page cache entry has _INT
            // object, we need the full setup AST. Try to use a cache entry for setup AST, which especially up _INT
            // parsing. In unavailable, calculate full setup AST and cache it if allowed.
            $gotSetupFromCache = false;
            if ($setupTypoScriptCache = $typoScriptCache?->require($setupTypoScriptCacheIdentifier)) {
                // We need AST, and we got it from cache.
                $frontendTypoScript->setSetupTree($setupTypoScriptCache['ast']);
                $frontendTypoScript->setSetupArray($setupTypoScriptCache['array']);
                $setupRawConfigAst = $setupTypoScriptCache['ast']->getChildByName('config');
                $gotSetupFromCache = true;
            }
            if (!$typoScriptCache || !$gotSetupFromCache) {
                // We need AST and couldn't get it from cache or are now allowed to. We thus need the full setup
                // IncludeTree, which we can get from cache again if allowed, or is calculated a-new if not.
                $setupIncludeTree = $frontendTypoScript->getSetupIncludeTree();
                if (!$typoScriptCache || $setupIncludeTree === null) {
                    // A previous method *may* have calculated setup include tree already. Calculate now if not.
                    $setupIncludeTree = $this->treeBuilder->getTreeBySysTemplateRowsAndSite('setup', $sysTemplateRows, $this->tokenizer, $site, $typoScriptCache);
                }
                $visitors = [];
                $conditionConstantSubstitutionVisitor = $this->container->get(IncludeTreeSetupConditionConstantSubstitutionVisitor::class);
                $conditionConstantSubstitutionVisitor->setFlattenedConstants($frontendTypoScript->getFlatSettings());
                $visitors[] = $conditionConstantSubstitutionVisitor;
                $conditionMatcherVisitor = $this->container->get(IncludeTreeConditionMatcherVisitor::class);
                $conditionMatcherVisitor->initializeExpressionMatcherWithVariables($expressionMatcherVariables);
                $visitors[] = $conditionMatcherVisitor;
                $astBuilderVisitor = $this->container->get(IncludeTreeAstBuilderVisitor::class);
                $astBuilderVisitor->setFlatConstants($frontendTypoScript->getFlatSettings());
                $visitors[] = $astBuilderVisitor;
                $this->includeTreeTraverserConditionVerdictAware->traverse($setupIncludeTree, $visitors);
                $setupAst = $astBuilderVisitor->getAst();
                // @todo: It would be good to actively remove 'config' from AST and array here
                //        to prevent people from using the unmerged variant. The same
                //        is already done for the determined PAGE 'config' below. This works, but
                //        is currently blocked by functional tests that assert details?
                //        Also, we need to still cache with full 'config' to handle multiple types.
                $setupRawConfigAst = $setupAst->getChildByName('config');
                // $setupAst->removeChildByName('config');
                $frontendTypoScript->setSetupTree($setupAst);
                $frontendTypoScript->setSetupArray($setupAst->toArray());
 
                // Write cache entry for AST and its array representation.
                $typoScriptCache?->set(
                    $setupTypoScriptCacheIdentifier,
                    'return unserialize(\'' . addcslashes(serialize(['ast' => $setupAst, 'array' => $setupAst->toArray()]), '\'\\') . '\');'
                );
            }
 
            $setupAst = $frontendTypoScript->getSetupTree();
            $rawSetupPageNodeFromType = null;
            $pageNodeFoundByType = false;
            foreach ($setupAst->getNextChild() as $potentialPageNode) {
                // Find the PAGE object that matches given type/typeNum
                if ($potentialPageNode->getValue() === 'PAGE') {
                    // @todo: We could potentially remove *all* PAGE objects from setup here. This prevents people
                    //        from accessing other ones than the determined one in $frontendTypoScript->getSetupArray().
                    $typeNumChild = $potentialPageNode->getChildByName('typeNum');
                    if ($typeNumChild && $type === $typeNumChild->getValue()) {
                        $rawSetupPageNodeFromType = $potentialPageNode;
                        $pageNodeFoundByType = true;
                        break;
                    }
                    if (!$typeNumChild && $type === '0') {
                        // The first PAGE node that has no typeNum is considered '0' automatically.
                        $rawSetupPageNodeFromType = $potentialPageNode;
                        $pageNodeFoundByType = true;
                        break;
                    }
                }
            }
            if (!$pageNodeFoundByType) {
                $rawSetupPageNodeFromType = new RootNode();
            }
            $setupPageAst = new RootNode();
            foreach ($rawSetupPageNodeFromType->getNextChild() as $child) {
                $setupPageAst->addChild($child);
            }
 
            if (!$gotSetupConfigFromCache) {
                // If we did not get merged 'config.' from cache above, create it now and cache it.
                $mergedSetupConfigAst = (new SetupConfigMerger())->merge($setupRawConfigAst, $setupPageAst->getChildByName('config'));
                if ($mergedSetupConfigAst->getChildByName('absRefPrefix') === null) {
                    // Make sure config.absRefPrefix is set, fallback to 'auto'.
                    $absRefPrefixNode = new ChildNode('absRefPrefix');
                    $absRefPrefixNode->setValue('auto');
                    $mergedSetupConfigAst->addChild($absRefPrefixNode);
                }
                if ($mergedSetupConfigAst->getChildByName('doctype') === null) {
                    // Make sure config.doctype is set, fallback to 'html5'.
                    $doctypeNode = new ChildNode('doctype');
                    $doctypeNode->setValue('html5');
                    $mergedSetupConfigAst->addChild($doctypeNode);
                }
                if ($request) {
                    // Dispatch ModifyTypoScriptConfigEvent before config is cached and if Request is given.
                    $mergedSetupConfigAst = $this->eventDispatcher
                        ->dispatch(new ModifyTypoScriptConfigEvent($request, $setupAst, $mergedSetupConfigAst))->getConfigTree();
                }
                $frontendTypoScript->setConfigTree($mergedSetupConfigAst);
                $setupConfigArray = $mergedSetupConfigAst->toArray();
                $frontendTypoScript->setConfigArray($setupConfigArray);
                $typoScriptCache?->set(
                    $setupConfigTypoScriptCacheIdentifier,
                    'return unserialize(\'' . addcslashes(serialize(['ast' => $mergedSetupConfigAst, 'array' => $setupConfigArray]), '\'\\') . '\');'
                );
            }
 
            if ($pageNodeFoundByType) {
                // Remove "page.config" to prevent people from working with the not merged variant.
                // We do *not* set page if it could not be determined (important for hasPage() later
                // to return an early "no PAGE for type found" Response.
                $setupPageAst->removeChildByName('config');
                $frontendTypoScript->setPageTree($setupPageAst);
                $frontendTypoScript->setPageArray($setupPageAst->toArray());
            }
        }
        return $frontendTypoScript;
    }
}