class RelationshipNormalizer

class RelationshipNormalizer extends NormalizerBase {
  use SchematicNormalizerTrait;
  
  /**
   * Constructor.
   *
   * @param \Drupal\jsonapi\ResourceType\ResourceTypeRepositoryInterface $resourceTypeRepository
   *   Resource type repository.
   */
  public function __construct(protected ResourceTypeRepositoryInterface $resourceTypeRepository) {
  }
  
  /**
   * Normalizes data into a set of arrays/scalars.
   *
   * @param \Drupal\jsonapi\JsonApiResource\Relationship $object
   *   Data to normalize.
   * @param string|null $format
   *   Format the normalization result will be encoded as.
   * @param array<string, mixed> $context
   *   Context options for the normalizer.
   *
   * @return array|string|int|float|bool|\ArrayObject<mixed, mixed>|null
   *   \ArrayObject is used to make sure an empty object is encoded as an
   *   object not an array.
   */
  public function doNormalize($object, $format = NULL, array $context = []) : array|string|int|float|bool|\ArrayObject|null {
    assert($object instanceof Relationship);
    return CacheableNormalization::aggregate([
      'data' => $this->serializer
        ->normalize($object->getData(), $format, $context),
      'links' => $this->serializer
        ->normalize($object->getLinks(), $format, $context)
        ->omitIfEmpty(),
      'meta' => CacheableNormalization::permanent($object->getMeta())
        ->omitIfEmpty(),
    ]);
  }
  
  /**
   * {@inheritdoc}
   */
  public function getNormalizationSchema(mixed $object, array $context = []) : array {
    assert($object instanceof Relationship);
    $schema = [
      'allOf' => [
        [
          '$ref' => JsonApiSpec::SUPPORTED_SPECIFICATION_JSON_SCHEMA . '#/definitions/relationship',
        ],
      ],
    ];
    $field_definition = $object->getContext()
      ->getField($object->getFieldName())?->getFieldDefinition();
    $item_class = $field_definition?->getItemDefinition()->getClass();
    assert($item_class, sprintf('The context ResourceObject for Relationship being normalized is missing field %s.', $object->getFieldName()));
    if (!$item_class || !is_subclass_of($item_class, EntityReferenceItemInterface::class)) {
      return $schema;
    }
    $targets = $item_class::getReferenceableBundles($field_definition);
    $target_types = array_reduce(array_keys($targets), function (array $carry, string $entity_type_id) use ($targets) {
      foreach ($targets[$entity_type_id] as $bundle) {
        // Even if a resource is internal, it can be referenced.
        if (!($resource = $this->resourceTypeRepository
          ->get($entity_type_id, $bundle)) || in_array($resource->getTypeName(), $carry)) {
          continue;
        }
        $carry[] = $resource->getTypeName();
      }
      return $carry;
    }, []);
    if ($target_types) {
      $schema['properties']['type'] = [
        'oneOf' => array_map(fn(string $resource_type_name) => [
          'const' => $resource_type_name,
        ], $target_types),
      ];
    }
    return $schema;
  }
  
  /**
   * {@inheritdoc}
   */
  public function getSupportedTypes(?string $format) : array {
    return [
      Relationship::class => TRUE,
    ];
  }

}