PIM-koppeling zonder vendor lock-in: de middleware aanpak

Akeneo API  ──►  AkeneoConnector  ──►  [Intern Product Model]  ──►  MagentoConnector  ──►  Magento API
Pimcore API ──►  PimcoreConnector ──►  [Intern Product Model]  ──►  ShopifyConnector  ──►  Shopify API

// Intern product model — platform-agnostisch
class ProductData
{
    public function __construct(
        public readonly string $sku,
        public readonly string $naam,
        public readonly ?string $beschrijving,
        public readonly ProductStatus $status,
        public readonly array $attributen,
        public readonly array $categorieIds,
        public readonly array $afbeeldingen,
        public readonly array $kanaalbewerkingen, // Per-channel overrides
    ) {}
}

// Attribuut — generiek maar typed
class ProductAttribuut
{
    public function __construct(
        public readonly string $code,
        public readonly string $type, // text, number, select, multiselect, boolean
        public readonly mixed $waarde,
        public readonly ?string $taalcode,
        public readonly ?string $scoop, // global, website, storeview
    ) {}
}

class AkeneoConnector implements PimConnector
{
    public function __construct(
        private readonly AkeneoClient $client,
        public readonly AttributeMappingRepository $mapping,
    ) {}

    public function haalProductOp(string $sku): ProductData
    {
        $akeneoProduct = $this->client->getProduct($sku);

        return new ProductData(
            sku: $akeneoProduct['identifier'],
            naam: $this->haalWaarde($akeneoProduct, 'name', 'nl_NL'),
            beschrijving: $this->haalWaarde($akeneoProduct, 'description', 'nl_NL'),
            status: $akeneoProduct['enabled'] ? ProductStatus::Actief : ProductStatus::Inactief,
            attributen: $this->mapAttributen($akeneoProduct['values']),
            categorieIds: $akeneoProduct['categories'],
            afbeeldingen: $this->haalAfbeeldingen($akeneoProduct),
            kanaalbewerkingen: [],
        );
    }

    private function mapAttributen(array $akeneoWaarden): array
    {
        $attributen = [];

        foreach ($akeneoWaarden as $code => $waarden) {
            // Akeneo geeft waarden per locale en scope terug
            foreach ($waarden as $waarde) {
                $attributen[] = new ProductAttribuut(
                    code: $code,
                    type: $this->mapping->getType($code),
                    waarde: $waarde['data'],
                    taalcode: $waarde['locale'],
                    scoop: $waarde['scope'],
                );
            }
        }

        return $attributen;
    }

    private function haalWaarde(array $product, string $attribuut, string $locale): ?string
    {
        return $product['values'][$attribuut][0]['data'] ?? null;
    }
}

class MagentoConnector implements ChannelConnector
{
    public function __construct(
        private readonly MagentoClient $client,
        private readonly AttributeTranslator $translator,
    ) {}

    public function synchroniseerProduct(ProductData $product, string $storeCode = 'default'): void
    {
        $magentoProduct = [
            'sku' => $product->sku,
            'name' => $product->naam,
            'status' => $product->status === ProductStatus::Actief ? 1 : 2,
            'visibility' => 4, // Catalogus + zoeken
            'type_id' => 'simple',
            'attribute_set_id' => $this->translator->getAttributeSetId($product),
            'custom_attributes' => $this->mapCustomAttributen($product->attributen),
        ];

        // Controleer of product al bestaat
        try {
            $this->client->putProduct($product->sku, $magentoProduct, $storeCode);
        } catch (ProductNotFoundException) {
            $this->client->postProduct($magentoProduct);
        }

        // Afbeeldingen apart synchroniseren
        $this->synchroniseerAfbeeldingen($product->sku, $product->afbeeldingen);
    }

    private function mapCustomAttributen(array $attributen): array
    {
        return collect($attributen)
            ->map(fn(ProductAttribuut $a) => [
                'attribute_code' => $a->code,
                'value' => $this->translator->formatWaarde($a),
            ])
            ->values()
            ->toArray();
    }
}

class SynchroniseerProductJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;
    public int $backoff = 60; // Wacht 60 seconden tussen pogingen

    public function __construct(
        private readonly string $sku,
        private readonly string $pimConnector,
        private readonly array $targetChannels,
    ) {}

    public function handle(
        ConnectorFactory $factory,
    ): void {
        // Haal data op uit PIM via de correcte connector
        $pim = $factory->makePim($this->pimConnector);
        $product = $pim->haalProductOp($this->sku);

        // Distribueer naar alle target channels
        foreach ($this->targetChannels as $channel) {
            $connector = $factory->makeChannel($channel);
            $connector->synchroniseerProduct($product);
        }
    }

    public function failed(Throwable $exception): void
    {
        // Log en eventueel alert versturen
        Log::error("Product sync mislukt voor SKU {$this->sku}", [
            'exception' => $exception->getMessage(),
            'pim' => $this->pimConnector,
        ]);
    }
}