IQ2i / data-importer

src/DataImporter.php

<?php

declare(strict_types=1);

/*
 * This file is part of the DataImporter package.
 *
 * (c) Loïc Sapone <loic@sapone.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace IQ2i\DataImporter;

use IQ2i\DataImporter\Archiver\ArchiverInterface;
use IQ2i\DataImporter\Exchange\MessageFactory;
use IQ2i\DataImporter\Processor\BatchProcessorInterface;
use IQ2i\DataImporter\Processor\ProcessorInterface;
use IQ2i\DataImporter\Reader\ReaderInterface;
use Symfony\Component\Filesystem\Exception\IOException;
use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\SerializerInterface;

class DataImporter
{
    private readonly SerializerInterface $serializer;

    public function __construct(
        private readonly ReaderInterface $reader,
        private readonly ProcessorInterface $processor,
        private readonly ?ArchiverInterface $archiver = null,
        ?SerializerInterface $serializer = null,
    ) {
        $this->serializer = $serializer ?? new Serializer([new ObjectNormalizer(null, new CamelCaseToSnakeCaseNameConverter())]);

The property serializer is declared read-only in IQ2i\DataImporter\DataImporter.

    }

    public function execute(): void
    {
        $this->processor->begin(MessageFactory::create($this->reader));

        foreach ($this->reader as $data) {
            $message = MessageFactory::create(
                $this->reader,
                $this->reader->isDenormalizable() ? $this->serializeData($data) : $data
            );

            $this->processor->item($message);

            if ($this->processor instanceof BatchProcessorInterface && (
                0 === $this->reader->index() % $this->processor->getBatchSize() || $this->reader->index() === $this->reader->count()

The method getBatchSize() does not exist on IQ2i\DataImporter\Processor\ProcessorInterface. It seems like you code against a sub-type of IQ2i\DataImporter\Processor\ProcessorInterface such as IQ2i\DataImporter\Processor\BatchProcessorInterface.

            )) {
                $this->processor->batch(MessageFactory::create($this->reader));

The method batch() does not exist on IQ2i\DataImporter\Processor\ProcessorInterface. It seems like you code against a sub-type of IQ2i\DataImporter\Processor\ProcessorInterface such as IQ2i\DataImporter\Processor\BatchProcessorInterface.

            }
        }

        $archivedFilePath = null;
        if (null !== $this->archiver) {
            $archivedFilePath = $this->doArchive();
        }

        $this->processor->end(MessageFactory::create($this->reader, null, $archivedFilePath));
    }

    private function serializeData(array $data): mixed
    {
        try {
            /** @var Serializer $serializer */
            $serializer = $this->serializer;

            return $serializer->denormalize($data, $this->reader->getDto());

It seems like $this->reader->getDto() can also be of type null; however, parameter $type of Symfony\Component\Serializer\Serializer::denormalize() does only seem to accept string, maybe add an additional type check?

        } catch (\Exception $exception) {
            throw new \InvalidArgumentException('An error occurred while denormalizing data: '.$exception->getMessage(), $exception->getCode(), $exception);
        }
    }

    private function doArchive(): string
    {
        try {
            return $this->archiver->archive($this->reader->getFile());

The method archive() does not exist on null.

        } catch (IOException $ioException) {
            throw new IOException('An error occurred while archiving file: '.$ioException->getMessage());
        }
    }
}