initial commit.

bin/composer

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec docker compose run --rm --user "$(id -u):$(id -g)" --no-deps php composer "$@"

bin/run-tests

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+docker compose run --rm --user "$(id -u):$(id -g)" php composer tests
+docker compose down

config/index/elastically.yaml

@@ -0,0 +1,5 @@
+services:
+
+  Neusta\ElasticBundle\Index\Elastically\IndexesRepository:
+    arguments:
+      $client: '@JoliCode\Elastically\Client'

config/index/registry.yaml

@@ -0,0 +1,11 @@
+services:
+
+  neusta.elastic_bundle.registry.converter:
+    class: Neusta\ElasticBundle\Index\Registry\ObjectRegistry
+    arguments:
+      $name: 'converter'
+
+  neusta.elastic_bundle.registry.repository:
+    class: Neusta\ElasticBundle\Index\Registry\ObjectRegistry
+    arguments:
+      $name: 'repository'

config/services.yaml

@@ -0,0 +1,12 @@
+imports:
+  - { resource: index/* }
+
+services:
+  _defaults:
+    autowire: true
+    autoconfigure: true
+
+  JoliCode\Elastically\Client:
+    arguments:
+      $config:
+        elastically_index_class_mapping: []

src/Command/CreateIndexCommand.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\Command;
+
+use JoliCode\Elastically\Client;
+use Neusta\ElasticIndexBundle\Index\Elastically\IndexesRepository;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+final class CreateIndexCommand extends Command
+{
+    protected static $defaultName = 'neusta:elastic:index:create';
+
+    private Client $client;
+    private IndexesRepository $indexesRepository;
+
+    public function __construct(Client $client, IndexesRepository $indexesRepository)
+    {
+        parent::__construct();
+        $this->client = $client;
+        $this->indexesRepository = $indexesRepository;
+    }
+
+    protected function configure(): void
+    {
+        $this->setDescription('Create Elasticsearch indexes.');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $output->writeln('Start creating new indexes and move aliases.');
+
+        $indexBuilder = $this->client->getIndexBuilder();
+
+        foreach ($this->indexesRepository->getAllIndexes() as $indexName) {
+            $indexBuilder->markAsLive($indexBuilder->createIndex($indexName), $indexName);
+            $indexBuilder->purgeOldIndices($indexName);
+        }
+
+        $output->writeln('Creating indexes done');
+
+        return Command::SUCCESS;
+    }
+}

src/Command/IndexCommand.php

@@ -0,0 +1,62 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\Command;
+
+use Neusta\ElasticIndexBundle\Index\Data\DataRepository;
+use Neusta\ElasticIndexBundle\Index\Data\Filter\DataFilter;
+use Neusta\ElasticIndexBundle\Index\Data\Messenger\DataMessageFactory;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+final class IndexCommand extends Command
+{
+    protected static $defaultName = 'neusta:elastic:index:data';
+
+    public function __construct(
+        private DataRepository $repository,
+        private DataFilter $filter,
+        private DataMessageFactory $messageFactory,
+        private MessageBusInterface $bus,
+    ) {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this->setDescription('Re-index your data.');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $dataObjects = $this->repository->findAll();
+
+        $filteredElements = $this->filter->filter($dataObjects);
+
+        $io = new SymfonyStyle($input, $output);
+
+        $io->title('Start indexing');
+        $io->writeln([
+            sprintf('Repository returns %s items.', \count($dataObjects)),
+            '(The number of Elements returned from the Repository may differ from the number of actually indexed Elements due to filter constraints.)',
+            '',
+        ]);
+
+        $io->section('Index counter');
+
+        foreach ($io->progressIterate($filteredElements) as $dataObject) {
+            $message = $this->messageFactory->create($dataObject);
+            $this->bus->dispatch($message);
+        }
+
+        $output->writeln([
+            '',
+            '',
+            'Done',
+        ]);
+
+        return Command::SUCCESS;
+    }
+}

src/DependencyInjection/Compiler/ConverterRegistryPass.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+final class ConverterRegistryPass implements CompilerPassInterface
+{
+    private const TAG_NAME = 'neusta.elastic_bundle.converter';
+    private const REGISTRY_KEY = 'registry_key'; // @phpstan-ignore-line
+
+    public function process(ContainerBuilder $container): void
+    {
+        $registryDefinition = $container->getDefinition('neusta.elastic_bundle.registry.converter');
+
+        foreach ($container->findTaggedServiceIds(self::TAG_NAME, true) as $id => $tags) {
+            foreach ($tags as [self::REGISTRY_KEY => $registryKey]) {
+                $registryDefinition->addMethodCall('register', [$registryKey, new Reference($id)]);
+            }
+        }
+    }
+}

src/DependencyInjection/Compiler/RepositoryRegistryPass.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+final class RepositoryRegistryPass implements CompilerPassInterface
+{
+    private const TAG_NAME = 'neusta.elastic_bundle.repository';
+    private const REGISTRY_KEY = 'registry_key'; // @phpstan-ignore-line
+
+    public function process(ContainerBuilder $container): void
+    {
+        $registryDefinition = $container->getDefinition('neusta.elastic_bundle.registry.repository');
+
+        foreach ($container->findTaggedServiceIds(self::TAG_NAME, true) as $id => $tags) {
+            foreach ($tags as [self::REGISTRY_KEY => $registryKey]) {
+                $registryDefinition->addMethodCall('register', [$registryKey, new Reference($id)]);
+            }
+        }
+    }
+}

src/DependencyInjection/Configuration.php

@@ -0,0 +1,66 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\DependencyInjection;
+
+use Neusta\ElasticIndexBundle\Index\Data\Filter\NoOperationFilter;
+use Neusta\ElasticIndexBundle\Pimcore\Index\DataObjectRepository;
+use Neusta\ElasticIndexBundle\Pimcore\Index\PageRepository;
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+
+/**
+ * This is the class that validates and merges configuration from your app/config files.
+ *
+ * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/configuration.html}
+ */
+final class Configuration implements ConfigurationInterface
+{
+    public function getConfigTreeBuilder(): TreeBuilder
+    {
+        $treeBuilder = new TreeBuilder('neusta_elastic');
+        $root = $treeBuilder->getRootNode();
+
+        $root
+            ->children()
+                ->arrayNode('hosts')
+                    ->scalarPrototype()->end()
+                    ->defaultValue(['elasticsearch:9200'])
+                ->end()
+                ->arrayNode('commands')
+                    ->addDefaultsIfNotSet()
+                    ->children()
+                        ->arrayNode('data_object')
+                            ->addDefaultsIfNotSet()
+                            ->children()
+                                ->booleanNode('enable_default_handler')->defaultTrue()->end()
+                                ->scalarNode('repository')
+                                    ->info('Service id of the "DataObjectRepository" that is used in the neusta:elastic:index:objects command.')
+                                    ->defaultValue(DataObjectRepository::class)
+                                ->end()
+                                ->scalarNode('filter')
+                                    ->info('Service id of the "DataObjectFilter" that is used in the neusta:elastic:index:objects command.')
+                                    ->defaultValue(NoOperationFilter::class)
+                                ->end()
+                            ->end()
+                        ->end()
+                        ->arrayNode('page')
+                            ->addDefaultsIfNotSet()
+                            ->children()
+                                ->booleanNode('enable_default_handler')->defaultTrue()->end()
+                                ->scalarNode('repository')
+                                    ->info('Service id of the "PageRepository" that is used in the neusta:elastic:index:pages command.')
+                                    ->defaultValue(PageRepository::class)
+                                ->end()
+                                ->scalarNode('filter')
+                                    ->info('Service id of the "PageFilter" that is used in the neusta:elastic:index:pages command.')
+                                    ->defaultValue(NoOperationFilter::class)
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+            ->end();
+
+        return $treeBuilder;
+    }
+}

src/DependencyInjection/NeustaElasticExtension.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\DependencyInjection;
+
+use Neusta\ElasticIndexBundle\Pimcore\Index\Command\IndexDataObjectsCommand;
+use Neusta\ElasticIndexBundle\Pimcore\Index\Command\IndexPagesCommand;
+use Symfony\Component\Config\FileLocator;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Loader;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension;
+
+final class NeustaElasticExtension extends ConfigurableExtension
+{
+    protected function loadInternal(array $mergedConfig, ContainerBuilder $container): void  // @phpstan-ignore-line
+    {
+        $loader = new Loader\YamlFileLoader($container, new FileLocator(\dirname(__DIR__, 2) . '/config'));
+        $loader->load('services.yaml');
+
+        $container->setParameter('neusta_elastic.elasticsearch_hosts', $mergedConfig['hosts']);
+
+        // 'commands.data_object' config
+        if (true === $mergedConfig['commands']['data_object']['enable_default_handler']) {
+            $loader->load('services/pimcore/default_handler_data_object.yaml');
+        }
+        $serviceIdRepository = $mergedConfig['commands']['data_object']['repository'];
+        $serviceIdFilter = $mergedConfig['commands']['data_object']['filter'];
+        $indexDataObjectsCommand = $container->getDefinition(IndexDataObjectsCommand::class);
+        $indexDataObjectsCommand->setArgument('$repository', new Reference($serviceIdRepository));
+        $indexDataObjectsCommand->setArgument('$filter', new Reference($serviceIdFilter));
+
+        // 'commands.page' config
+        if (true === $mergedConfig['commands']['page']['enable_default_handler']) {
+            $loader->load('services/pimcore/default_handler_page.yaml');
+        }
+        $serviceIdRepository = $mergedConfig['commands']['page']['repository'];
+        $serviceIdFilter = $mergedConfig['commands']['page']['filter'];
+        $indexPagesCommand = $container->getDefinition(IndexPagesCommand::class);
+        $indexPagesCommand->setArgument('$repository', new Reference($serviceIdRepository));
+        $indexPagesCommand->setArgument('$filter', new Reference($serviceIdFilter));
+    }
+}

src/Index/Data/DataCollection.php

@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\Index\Data;
+
+/**
+ * @template T of object
+ */
+interface DataCollection extends \IteratorAggregate, \Countable
+{
+    /**
+     * @return \Traversable<int, T>
+     */
+    public function getIterator(): \Traversable;
+}

src/Index/Data/DataRepository.php

@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\Index\Data;
+
+/**
+ * @template T of object
+ */
+interface DataRepository
+{
+    /**
+     * @return DataCollection<T>
+     */
+    public function findAll(): DataCollection;
+}

src/Index/Data/Factory/ElasticDocumentFactory.php

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\Index\Data\Factory;
+
+use Neusta\ConverterBundle\Converter\Context\GenericContext;
+use Neusta\ConverterBundle\TargetFactory;
+use Neusta\ElasticIndexBundle\Index\Document\ElasticDocument;
+
+/**
+ * @extends TargetFactory<ElasticDocument, GenericContext>
+ */
+interface ElasticDocumentFactory extends TargetFactory
+{
+    public function create(object $ctx = null): ElasticDocument;
+}

src/Index/Data/Filter/AbstractDataFilter.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types=1);
+
+namespace Neusta\ElasticIndexBundle\Index\Data\Filter;
+
+use Neusta\ElasticIndexBundle\Index\Data\DataCollection;
+
+/**
+ * @template T of object
+ *
+ * @implements DataFilter<T>
+ */
+abstract class AbstractDataFilter implements DataFilter
+{
+    /**
+     * @param DataCollection<T> $elements
+     */
+    final public function filter(DataCollection $elements): iterable
+    {
+        foreach ($elements as $element) {
+            if (null !== $this->filterOne($element)) {
+                yield $element;
+            }
+        }
+    }
+
+    /**
+     * @param T $element
+     *
+     * @return T|null
+     */
+    abstract public function filterOne(object $element): ?object;
+}