First version, extracted and tested

.woodpecker/code-style.yml

@@ -0,0 +1,8 @@
+pipeline:
+  code-style:
+    image: composer
+    commands:
+      - composer global config repositories.repo-name vcs https://git.digital-competence.de/Packages/php-codesniffer
+      - composer global config --no-plugins allow-plugins.dealerdirect/phpcodesniffer-composer-installer true
+      - composer global require digicomp/php-codesniffer:@dev
+      - composer global exec -- phpcs --runtime-set ignore_warnings_on_exit 1 --standard=DigiComp Classes/ Tests/

.woodpecker/functional-tests.yml

@@ -0,0 +1,32 @@
+workspace:
+  base: /woodpecker
+  path: package
+
+matrix:
+  include:
+    - FLOW_VERSION: 6.3
+      PHP_VERSION: 7.4
+    - FLOW_VERSION: 7.3
+      PHP_VERSION: 7.4
+    - FLOW_VERSION: 7.3
+      PHP_VERSION: 8.1
+    - FLOW_VERSION: 8.3
+      PHP_VERSION: 8.1
+
+pipeline:
+  functional-tests:
+    image: "thecodingmachine/php:${PHP_VERSION}-v4-cli"
+    environment:
+      # Enable the PDO_SQLITE extension
+      - "PHP_EXTENSION_PDO_SQLITE=1"
+      - "FLOW_VERSION=${FLOW_VERSION}"
+      - "NEOS_BUILD_DIR=/woodpecker/Build-${FLOW_VERSION}"
+    commands:
+      - "sudo mkdir $NEOS_BUILD_DIR"
+      - "sudo chown -R docker:docker $NEOS_BUILD_DIR"
+      - "cd $NEOS_BUILD_DIR"
+      - "composer create-project --no-install neos/flow-base-distribution:^$FLOW_VERSION ."
+      - "composer config repositories.repo-name path /woodpecker/package"
+      - "composer config --no-plugins allow-plugins.neos/composer-plugin true"
+      - "composer require digicomp/flow-translation-endpoint:@dev"
+      - "bin/phpunit --configuration Build/BuildEssentials/PhpUnit/FunctionalTests.xml Packages/Application/DigiComp.FlowTranslationEndpoint/Tests/Functional"

Classes/Http/ReplaceGetTranslationRequest.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigiComp\FlowTranslationEndpoint\Http;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class ReplaceGetTranslationRequest implements MiddlewareInterface
+{
+    /**
+     * @var string
+     */
+    protected string $headerName;
+
+    /**
+     * @var string|null
+     */
+    protected ?string $reactOnPath;
+
+    /**
+     * @var string
+     */
+    protected string $translateGetParam;
+
+    /**
+     * @param string $headerName
+     * @param string|null $reactOnPath
+     * @param string $translateGetParam
+     */
+    public function __construct(string $headerName, ?string $reactOnPath, string $translateGetParam)
+    {
+        $this->headerName = $headerName;
+        $this->reactOnPath = $reactOnPath;
+        $this->translateGetParam = $translateGetParam;
+    }
+
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        if ($this->reactOnPath !== null && $request->getUri()->getPath() === $this->reactOnPath) {
+            $request = $request->withAddedHeader(
+                $this->headerName,
+                $request->getQueryParams()[$this->translateGetParam] ?? ''
+            );
+        }
+        return $handler->handle($request);
+    }
+}

Classes/Http/TranslationMiddleware.php

@@ -0,0 +1,143 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigiComp\FlowTranslationEndpoint\Http;
+
+use GuzzleHttp\Psr7\Response;
+use Neos\Cache\Exception as CacheException;
+use Neos\Cache\Exception\InvalidDataException;
+use Neos\Cache\Frontend\StringFrontend;
+use Neos\Flow\I18n\Detector;
+use Neos\Flow\I18n\Service;
+use Neos\Flow\I18n\Xliff\Service\XliffFileProvider;
+use Neos\Utility\Arrays;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class TranslationMiddleware implements MiddlewareInterface
+{
+    /**
+     * @var string
+     */
+    protected string $headerName;
+
+    /**
+     * @var Service
+     */
+    protected Service $i18nService;
+
+    /**
+     * @var XliffFileProvider
+     */
+    protected XliffFileProvider $fileProvider;
+
+    /**
+     * @var Detector
+     */
+    protected Detector $detector;
+
+    /**
+     * @var StringFrontend
+     */
+    protected StringFrontend $responseCache;
+
+    public function __construct(
+        string $headerName,
+        Service $i18nService,
+        XliffFileProvider $fileProvider,
+        Detector $detector,
+        StringFrontend $responseCache
+    ) {
+        $this->headerName = $headerName;
+        $this->i18nService = $i18nService;
+        $this->fileProvider = $fileProvider;
+        $this->detector = $detector;
+        $this->responseCache = $responseCache;
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     * @throws CacheException
+     * @throws InvalidDataException
+     * @throws \JsonException
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        if ($request->hasHeader($this->headerName)) {
+            return $this->createResponse($request);
+        }
+        return $handler->handle($request);
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     * @throws \JsonException
+     * @throws CacheException
+     * @throws InvalidDataException
+     */
+    protected function createResponse(ServerRequestInterface $request): ResponseInterface
+    {
+        if ($request->hasHeader('Accept-Language')) {
+            $wishedLocale = $this->detector->detectLocaleFromHttpHeader($request->getHeader('Accept-Language')[0]);
+            $bestMatching = $this->i18nService->findBestMatchingLocale($wishedLocale);
+            $this->i18nService->getConfiguration()->setCurrentLocale($bestMatching);
+        }
+        $idPatternList = $request->getHeader($this->headerName)[0] ?? '';
+        $cacheId = $this->i18nService->getConfiguration()->getCurrentLocale() . '_' . \sha1(\serialize($idPatternList));
+        if ($this->responseCache->has($cacheId)) {
+            $response = $this->responseCache->get($cacheId);
+        } else {
+            $result = $this->getTranslations(Arrays::trimExplode(',', $idPatternList));
+            $response = \json_encode($result, \JSON_THROW_ON_ERROR);
+            $this->responseCache->set($cacheId, $response);
+        }
+        return new Response(200, ['Content-Type' => 'application/json'], $response);
+    }
+
+    /**
+     * @param array $idPatternList
+     *
+     * @return array
+     */
+    protected function getTranslations(array $idPatternList): array
+    {
+        $result = [];
+        foreach ($idPatternList as $idPattern) {
+            $package = 'Neos.Flow:Main';
+            $parts = \explode('|', $idPattern);
+            switch (\count($parts)) {
+                case 2:
+                    [$package, $pattern] = $parts;
+                    break;
+                case 1:
+                    [$pattern] = $parts;
+                    break;
+                default:
+                    throw new \InvalidArgumentException('Could not parse idPattern: ' . $idPattern);
+            }
+            $translationUnits = $this->fileProvider->getFile(
+                $package,
+                $this->i18nService->getConfiguration()->getCurrentLocale()
+            )->getTranslationUnits();
+            if (!isset($result[$package])) {
+                $result[$package] = [];
+            }
+            $matchingUnits = \array_filter(
+                $translationUnits,
+                static fn($unitId) => \preg_match('~^' . $pattern . '$~', $unitId),
+                \ARRAY_FILTER_USE_KEY
+            );
+            $result[$package] += \array_map(
+                static fn($value) => $value[0]['target'],
+                $matchingUnits
+            );
+        }
+        return $result;
+    }
+}

Classes/ViewHelpers/CurrentHtmlLangViewHelper.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigiComp\FlowTranslationEndpoint\ViewHelpers;
+
+use Neos\Flow\I18n\Service as I18nService;
+use Neos\FluidAdaptor\Core\ViewHelper\AbstractViewHelper;
+
+class CurrentHtmlLangViewHelper extends AbstractViewHelper
+{
+    /**
+     * @var I18nService
+     */
+    protected I18nService $i18nService;
+
+    /**
+     * @param I18nService $i18nService
+     */
+    public function __construct(I18nService $i18nService)
+    {
+        $this->i18nService = $i18nService;
+    }
+
+    /**
+     * @return string
+     */
+    public function render(): string
+    {
+        return \str_replace('_', '-', (string)$this->i18nService->getConfiguration()->getCurrentLocale());
+    }
+}

Configuration/Caches.yaml

@@ -0,0 +1,3 @@
+DigiComp_FlowTranslationEndpoint_Responses:
+  frontend: Neos\Cache\Frontend\StringFrontend
+  backend: Neos\Cache\Backend\SimpleFileBackend

Configuration/Objects.yaml

@@ -0,0 +1,24 @@
+DigiComp:TransformTranslationRequest:
+  className: "DigiComp\\FlowTranslationEndpoint\\Http\\ReplaceGetTranslationRequest"
+  arguments:
+    1:
+      setting: "DigiComp.FlowTranslationEndpoint.headerName"
+    2:
+      setting: "DigiComp.FlowTranslationEndpoint.replaceRoutedEndpoint.reactOnPath"
+    3:
+      setting: "DigiComp.FlowTranslationEndpoint.replaceRoutedEndpoint.translateGetParam"
+
+DigiComp:TranslationResponseCache:
+  className: "Neos\\Cache\\Frontend\\StringFrontend"
+  factoryObjectName: Neos\Flow\Cache\CacheManager
+  factoryMethodName: getCache
+  arguments:
+    1:
+      value: DigiComp_FlowTranslationEndpoint_Responses
+
+DigiComp\FlowTranslationEndpoint\Http\TranslationMiddleware:
+  arguments:
+    1:
+      setting: "DigiComp.FlowTranslationEndpoint.headerName"
+    5:
+      object: "DigiComp:TranslationResponseCache"

Configuration/Settings.yaml

@@ -0,0 +1,17 @@
+Neos:
+  Flow:
+    http:
+      middlewares:
+        translationReplace:
+          position: "before translation"
+          middleware: "DigiComp:TransformTranslationRequest"
+        translation:
+          position: "start 100"
+          middleware: "DigiComp\\FlowTranslationEndpoint\\Http\\TranslationMiddleware"
+
+DigiComp:
+  FlowTranslationEndpoint:
+    replaceRoutedEndpoint:
+      reactOnPath: ~
+      translateGetParam: "idPatterns"
+    headerName: "X-Translation-Request"

Configuration/Testing/Settings.yaml

@@ -0,0 +1,5 @@
+DigiComp:
+  FlowTranslationEndpoint:
+    replaceRoutedEndpoint:
+      reactOnPath: 'testing/translate'
+    headerName: "X-Translation-Request"

README.md

@@ -0,0 +1,45 @@
+# DigiComp.FlowTranslationEndpoint
+
+![Build status](https://ci.digital-competence.de/api/badges/Packages/DigiComp.FlowTranslationEndpoint/status.svg)
+
+This package is designed to help bringing needed translations to javascript components, without pushing them to the DOM in your views.
+
+Other solutions, which would generate files available for usage in client scope, have the disadvantage that one would have to repeat the relativ complex overriding and merging logic of Flow. With this endpoint you can get the same content, as you would get, if you call the translation service with your translation id.
+
+The main components are a `CurrentHtmlLangViewHelper`, which is intended to be used to fill the `lang` attribute of the `html` tag, so the frontend knows, which language is currently active (and is good practice anyway) and a `TranslationMiddleware`, which will respond to any request, which have a `X-Translation-Request` header, carrying a pattern of translation ids which should be returned.
+
+For example:
+````
+X-Translation-Request: Neos.Flow:Main|authentication.*
+````
+
+would return all translation keys from the main unit of `Neos.Flow` starting with "authentication" and would look like that:
+
+```json
+{
+    "Neos.Flow:Main": {
+        "authentication.required": "Authentication required", 
+        "authentication.username": "Username",
+        "authentication.password": "Password", 
+        "authentication.new-password": "New password",
+        "authentication.login": "Login", 
+        "authentication.logout": "Logout"
+    }
+}
+```
+
+To let the middleware know, in which langauge the translated units should be, you should set the correct `Accept-Language`-Header with your request, which you obtained from the `lang` attribute of the `html` element.
+
+Your JavaScript could look like that:
+
+```javascript
+async function translate(idPatterns) {
+    return fetch(document.location, {headers: {
+        'X-Translation-Request': idPatterns,
+        'Accept-Language': document.documentElement.lang
+    }})
+        .then(response => response.json());
+}
+```
+
+If, for whatever reason, you prefer to have a "traditional" single endpoint, which works without a custom header, you can set `DigiComp.FlowTranslationEndpoint.replaceRoutedEndpoint.reactOnPath`. At this point a middleware translates all incoming requests and the GET parameter `idPatterns` (you can change the name in Settings.yaml).

Resources/Private/Translations/de/Test.xlf

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" version="1.2">
+    <file original="Test" product-name="DigiComp.FlowTranslationEndpoint" source-language="en" datatype="plaintext">
+        <body>
+            <trans-unit id="key1">
+                <source>de_key1</source>
+            </trans-unit>
+        </body>
+    </file>
+</xliff>

Resources/Private/Translations/en/Test.xlf

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" version="1.2">
+    <file original="Test" product-name="DigiComp.FlowTranslationEndpoint" source-language="en" datatype="plaintext">
+        <body>
+            <trans-unit id="key1">
+                <source>en_key1</source>
+            </trans-unit>
+        </body>
+    </file>
+</xliff>

Tests/Functional/TranslationMiddlewareTest.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigiComp\FlowTranslationEndpoint\Tests\Functional;
+
+use Neos\Flow\Tests\FunctionalTestCase;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+
+class TranslationMiddlewareTest extends FunctionalTestCase
+{
+    /**
+     * @var ServerRequestFactoryInterface
+     */
+    protected $serverRequestFactory;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->serverRequestFactory = $this->objectManager->get(ServerRequestFactoryInterface::class);
+    }
+
+    /**
+     * @test
+     */
+    public function itRespondsToRequestsWithTheConfiguredHeader(): void
+    {
+        $request = $this->serverRequestFactory->createServerRequest('GET', 'dummyUrl');
+        $request = $request
+            ->withHeader('X-Translation-Request', 'DigiComp.FlowTranslationEndpoint:Test|.*')
+            ->withHeader('Accept-Language', 'en');
+        $response = $this->browser->sendRequest($request);
+        static::assertEquals(
+            '{"DigiComp.FlowTranslationEndpoint:Test":{"key1":"en_key1"}}',
+            (string)$response->getBody()
+        );
+        $request = $this->serverRequestFactory->createServerRequest('GET', 'dummyUrl');
+        $request = $request
+            ->withHeader('X-Translation-Request', 'DigiComp.FlowTranslationEndpoint:Test|.*')
+            ->withHeader('Accept-Language', 'de');
+        $response = $this->browser->sendRequest($request);
+        static::assertEquals(
+            '{"DigiComp.FlowTranslationEndpoint:Test":{"key1":"de_key1"}}',
+            (string)$response->getBody()
+        );
+    }
+
+    /**
+     * @test
+     */
+    public function itRespondsToConfiguredRoute(): void
+    {
+        $request = $this->serverRequestFactory->createServerRequest('GET', 'testing/translate');
+        $request = $request
+            ->withQueryParams(['idPatterns' => 'DigiComp.FlowTranslationEndpoint:Test|.*'])
+            ->withHeader('Accept-Language', 'en');
+        $response = $this->browser->sendRequest($request);
+        static::assertEquals(
+            '{"DigiComp.FlowTranslationEndpoint:Test":{"key1":"en_key1"}}',
+            (string)$response->getBody()
+        );
+    }
+}

composer.json

@@ -0,0 +1,45 @@
+{
+    "name": "digicomp/flow-translation-endpoint",
+    "description": "A simple endpoint providing XLIFF translations as string",
+    "type": "neos-package",
+    "require": {
+        "ext-json": "*",
+        "neos/flow": "^6.3.0 | ^7.0 | ^8.0",
+        "php": ">=7.4"
+    },
+    "autoload": {
+        "psr-4": {
+            "DigiComp\\FlowTranslationEndpoint\\": "Classes/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "DigiComp\\FlowTranslationEndpoint\\Tests\\": "Tests/"
+        }
+    },
+    "extra": {
+        "neos": {
+            "package-key": "DigiComp.FlowTranslationEndpoint"
+        },
+        "branch-alias": {
+            "dev-develop": "1.0.x-dev"
+        }
+    },
+    "authors": [
+        {
+            "name": "Ferdinand Kuhl",
+            "email": "f.kuhl@digital-competence.de",
+            "homepage": "https://www.digital-competence.de",
+            "role": "Developer"
+        }
+    ],
+    "license": "MIT",
+    "homepage": "https://git.digital-competence.de/Packages/DigiComp.FlowTranslationEndpoint",
+    "keywords": [
+        "Neos",
+        "Flow",
+        "translation",
+        "xliff",
+        "json"
+    ]
+}