Jane

Simplifiez-vous la consommation d'API... et bien plus !

Baptiste Leduc

Un peu de contexte ...

🌱 Un ensemble de librairies pour générer des modèles et clients API basés sur les spécifications JSON Schema et OpenAPI

Elasticsearch

Via Elastically

JSON Schema

• Description
• Validation

Mon modèle

project/config/jane/json-schema.json

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "brewer": { "type": "string" },
    "style": { "type": "string" },
    "volume": { "type": "integer" },
    "alcohol": { "type": "integer" },
    "country": { "type": "string" },
    "color": { "type": "string" }
  }
}
                  

Configuration

project/config/jane/json_schema.php

return [
    'json-schema-file' => __DIR__ . '/json-schema.json',
    'root-class' => 'Beer',
    'namespace' => 'Generated',
    'directory' => __DIR__ . '/../../generated',
];
              

Génération

vendor/bin/jane generate -c config/jane/json_schema.php
              

Fichiers générés

Modèles

class Beer
{
    /**
     * 
     *
     * @var string
     */
    protected $name;
    /**
     * 
     *
     * @var string
     */
    protected $brewer;
    /**
     * 
     *
     * @var string
     */
    protected $style;
    /**
     * 
     *
     * @var int
     */
    protected $volume;
    /**
     * 
     *
     * @var int
     */
    protected $alcohol;
    /**
     * 
     *
     * @var string
     */
    protected $country;
    /**
     * 
     *
     * @var string
     */
    protected $color;
    /**
     * 
     *
     * @return string
     */
    public function getName() : string
    {
        return $this->name;
    }
    /**
     * 
     *
     * @param string $name
     *
     * @return self
     */
    public function setName(string $name) : self
    {
        $this->name = $name;
        return $this;
    }
    /**
     * 
     *
     * @return string
     */
    public function getBrewer() : string
    {
        return $this->brewer;
    }
    /**
     * 
     *
     * @param string $brewer
     *
     * @return self
     */
    public function setBrewer(string $brewer) : self
    {
        $this->brewer = $brewer;
        return $this;
    }
    /**
     * 
     *
     * @return string
     */
    public function getStyle() : string
    {
        return $this->style;
    }
    /**
     * 
     *
     * @param string $style
     *
     * @return self
     */
    public function setStyle(string $style) : self
    {
        $this->style = $style;
        return $this;
    }
    /**
     * 
     *
     * @return int
     */
    public function getVolume() : int
    {
        return $this->volume;
    }
    /**
     * 
     *
     * @param int $volume
     *
     * @return self
     */
    public function setVolume(int $volume) : self
    {
        $this->volume = $volume;
        return $this;
    }
    /**
     * 
     *
     * @return int
     */
    public function getAlcohol() : int
    {
        return $this->alcohol;
    }
    /**
     * 
     *
     * @param int $alcohol
     *
     * @return self
     */
    public function setAlcohol(int $alcohol) : self
    {
        $this->alcohol = $alcohol;
        return $this;
    }
    /**
     * 
     *
     * @return string
     */
    public function getCountry() : string
    {
        return $this->country;
    }
    /**
     * 
     *
     * @param string $country
     *
     * @return self
     */
    public function setCountry(string $country) : self
    {
        $this->country = $country;
        return $this;
    }
    /**
     * 
     *
     * @return string
     */
    public function getColor() : string
    {
        return $this->color;
    }
    /**
     * 
     *
     * @param string $color
     *
     * @return self
     */
    public function setColor(string $color) : self
    {
        $this->color = $color;
        return $this;
    }
}
                

Serializer ?

Normalizers

class BeerNormalizer implements DenormalizerInterface, NormalizerInterface, DenormalizerAwareInterface, NormalizerAwareInterface
{
    use DenormalizerAwareTrait;
    use NormalizerAwareTrait;
    use CheckArray;
    public function supportsDenormalization($data, $type, $format = null)
    {
        return $type === 'Generated\\Model\\Beer';
    }
    public function supportsNormalization($data, $format = null)
    {
        return $data instanceof \Generated\Model\Beer;
    }
    public function denormalize($data, $class, $format = null, array $context = array())
    {
        if (isset($data['$ref'])) {
            return new Reference($data['$ref'], $context['document-origin']);
        }
        if (isset($data['$recursiveRef'])) {
            return new Reference($data['$recursiveRef'], $context['document-origin']);
        }
        $object = new \Generated\Model\Beer();
        if (\array_key_exists('name', $data)) {
            $object->setName($data['name']);
        }
        if (\array_key_exists('brewer', $data)) {
            $object->setBrewer($data['brewer']);
        }
        if (\array_key_exists('style', $data)) {
            $object->setStyle($data['style']);
        }
        if (\array_key_exists('volume', $data)) {
            $object->setVolume($data['volume']);
        }
        if (\array_key_exists('alcohol', $data)) {
            $object->setAlcohol($data['alcohol']);
        }
        if (\array_key_exists('country', $data)) {
            $object->setCountry($data['country']);
        }
        if (\array_key_exists('color', $data)) {
            $object->setColor($data['color']);
        }
        return $object;
    }
    public function normalize($object, $format = null, array $context = array())
    {
        $data = array();
        if (null !== $object->getName()) {
            $data['name'] = $object->getName();
        }
        if (null !== $object->getBrewer()) {
            $data['brewer'] = $object->getBrewer();
        }
        if (null !== $object->getStyle()) {
            $data['style'] = $object->getStyle();
        }
        if (null !== $object->getVolume()) {
            $data['volume'] = $object->getVolume();
        }
        if (null !== $object->getAlcohol()) {
            $data['alcohol'] = $object->getAlcohol();
        }
        if (null !== $object->getCountry()) {
            $data['country'] = $object->getCountry();
        }
        if (null !== $object->getColor()) {
            $data['color'] = $object->getColor();
        }
        return $data;
    }
}
                

Indexation

project/src/Command/IndexCommand.php

// On va récupérer l'index Elasticsearch

$beers = $this->beerRepository->findAll();
foreach ($beers as $beer) {
  $model = new \Generated\Beer();
  $model->setName($beer->getName());
  $model->setBrewer($beer->getBrewer());
  $model->setStyle($beer->getStyle());
  $model->setVolume($beer->getVolume());
  $model->setAlcohol($beer->getAlcohol());
  $model->setCountry($beer->getCountry());
  $model->setColor($beer->getColor());

  $document = new \Elastica\Document($beer->getId(), $model);
  $indexer->scheduleIndex(self::BEERS_INDEX, $document);
}

// Puis on envoit les documents à Elasticsearch
                  

AutoMapper

Transformer

final class Mapper_App_Entity_Beer_Generated_Model_Beer extends \Jane\AutoMapper\Mapper
{
    protected $hash = '15937785381593778538';
    public function __construct()
    {
    }
    public function &map($value, \Jane\AutoMapper\Context $context)
    {
        if (null === $value) {
            return $value;
        }
        $result = $context->getObjectToPopulate();
        if (null === $result) {
            $result = new \Generated\Model\Beer();
        }
        if ($context->isAllowedAttribute('style')) {
            $result->setstyle($value->getstyle());
        }
        if ($context->isAllowedAttribute('volume')) {
            $result->setvolume($value->getvolume());
        }
        if ($context->isAllowedAttribute('alcohol')) {
            $result->setalcohol($value->getalcohol());
        }
        if ($context->isAllowedAttribute('name')) {
            $result->setname($value->getname());
        }
        if ($context->isAllowedAttribute('brewer')) {
            $result->setbrewer($value->getbrewer());
        }
        if ($context->isAllowedAttribute('country')) {
            $result->setcountry($value->getcountry());
        }
        if ($context->isAllowedAttribute('color')) {
            $result->setcolor($value->getcolor());
        }
        return $result;
    }
    public function injectMappers(\Jane\AutoMapper\AutoMapperInterface $autoMapper)
    {
    }
}
              

Des impacts possibles ...

• Remplacer l'ObjectNormalizer de Symfony
• Bridge symfony/form pour mapper les data en objet

Indexation

project/src/Command/IndexCommand.php

// On va récupérer l'index Elasticsearch

$beers = $this->beerRepository->findAll();
foreach ($beers as $beer) {
  $model = $this->autoMapper->map($beer, \Generated\Beer::class);
  $document = new \Elastica\Document($beer->getId(), $model);
  $indexer->scheduleIndex(self::BEERS_INDEX, $document);
}

// Puis on envoie les documents à Elasticsearch
              

Rendu

API externe

OpenAPI

• Endpoints
• Authentification

Configuration de la génération

project/config/jane/open_api.php

return [
  'openapi-file' => __DIR__ . '/open-api.yaml',
  'namespace' => 'CatFacts\Api',
  'directory' => __DIR__ . '/../../generated',
  'date-format' => \DateTimeInterface::RFC3339_EXTENDED,
];
                

Configuration des services

project/config/packages/jane.yaml

services:
_defaults:
    autowire: true
    autoconfigure: true

CatFacts\Api\Normalizer\JaneObjectNormalizer: ~

CatFacts\Api\Client:
    factory: ['CatFacts\Api\Client', 'create']
                

Rendu

Démos

Merci

Des questions ?