Metatag with 4.x

[bejes]

Are there any examples of metatag / metadata with current 4.x?
I don't see any mention in the docs or dataproducers.

[davepoon]

I am having the same issue with 4.x. I have no success of getting metatag data with Data Producers.

[axooh]

Same here, would be interested in how to create data producers for metatags.

[bejes]

I did get this working using the metatag_normalized field.
Using https://www.drupal.org/project/metatag/issues/2945817 this patch with metatag v1.13.

[axooh]

@bejes: Thanks! Will look into that.

[bejes]

So for schema i did
type Section implements Node {
....
metatags: [MetaTag]
}
type MetaTag {
key: String
attributes: [String]
}

Then for the dataproducer, based that on the property_path producer.
And because its normalized you need to use executeInRenderContext.

$bubbleable = new BubbleableMetadata();
$fetcher = $this->getDataFetcher();

$context = new RenderContext();
$path = 'metatag_normalized';

$result = $this->renderer->executeInRenderContext($context, function () use ($fetcher, $value, $path, $bubbleable) {
  $output = $fetcher->fetchDataByPropertyPath($value, $path, $bubbleable)->getValue();
  return $output;
});

if (!$context->isEmpty()) {
  $metadata->addCacheableDependency($context->pop());
}

return $result;

Not sure if 100% best way but its working well.

[dottodot]

From what @bejes mentioned this is what I have

/**
 * Generates the metatags.
 *
 * @DataProducer(
 *   id = "meta_tag",
 *   name = @Translation("Metatag"),
 *   description = @Translation("return metatags."),
 *   produces = @ContextDefinition("string",
 *     label = @Translation("Path")
 *   ),
 *   consumes = {
 *     "value" = @ContextDefinition("any",
 *       label = @Translation("Root value")
 *     ),
 *     "type" = @ContextDefinition("string",
 *       label = @Translation("Root type"),
 *       required = FALSE
 *     )
 *   }
 * )
 */

class MetaTag extends DataProducerPluginBase implements ContainerFactoryPluginInterface
{
    use TypedDataTrait;
    use DataFetcherTrait;

     /**
      * The rendering service.
      *
      * @var \Drupal\Core\Render\RendererInterface
      */
    protected $renderer;

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public static function create(ContainerInterface $container, array $configuration, $pluginId, $pluginDefinition)
    {
        return new static(
            $configuration,
            $pluginId,
            $pluginDefinition,
            $container->get('renderer')
        );
    }

    /**
     * MetaTag constructor.
     *
     * @param array                                 $configuration
     *   The plugin configuration array.
     * @param string                                $pluginId
     *   The plugin id.
     * @param mixed                                 $pluginDefinition
     *   The plugin definition.
     * @param \Drupal\Core\Render\RendererInterface $renderer
     *   The renderer service.
     *
     * @codeCoverageIgnore
     */
    public function __construct(
        array $configuration,
        $pluginId,
        $pluginDefinition,
        RendererInterface $renderer
    ) {
        parent::__construct($configuration, $pluginId, $pluginDefinition);
        $this->renderer = $renderer;
    }
    /**
     * Resolver.
     *
     * @param mixed                                                    $value
     * @param string|null                                              $type
     * @param \Drupal\Core\Cache\RefinableCacheableDependencyInterface $metadata
     *
     * @return mixed
     */
    public function resolve($value, $type, RefinableCacheableDependencyInterface $metadata)
    {

        if (!($value instanceof TypedDataInterface) && !empty($type)) {
            $manager = $this->getTypedDataManager();
            $definition = $manager->createDataDefinition($type);
            $value = $manager->create($definition, $value);
        }

        if (!($value instanceof TypedDataInterface)) {
            throw new \BadMethodCallException('Could not derive typed data type.');
        }

        $context = new RenderContext();
        $path = 'metatag_normalized';
        $bubbleable = new BubbleableMetadata();
        $fetcher = $this->getDataFetcher();

        $result = $this->renderer->executeInRenderContext(
            $context, function () use ($fetcher, $value, $path, $bubbleable) {
                $output = $fetcher->fetchDataByPropertyPath(
                    $value,
                    $path,
                    $bubbleable
                )->getValue();
                return $output;
            }
        );

        if (!$context->isEmpty()) {
            $metadata->addCacheableDependency($context->pop());
        }

        return $result;
    }

}

For the schema

type LinkTag {
  rel: String
  href: String
}

type ContentTag {
  name: String
  content: String
}

interface MetaTags {
  tag: String
}

type MetaTagLink implements MetaTags {
  tag: String
  attributes: LinkTag
}

type MetaTagContent implements MetaTags {
  tag: String
  attributes: ContentTag
}

type Event implements Node {
  ...
  metatags: [MetaTags]
}

This also requires a resolver

        $registry->addTypeResolver(
            'MetaTags', function ($value) {
                switch ($value['tag']) {
                case 'link':
                    return 'MetaTagLink';
                case 'meta':
                    return 'MetaTagContent';
                }
                throw new Error('Could not resolve meta tag for: '. $tag);
            }
        );

this allows you to do a query like

      metatags {
        tag
        ... on MetaTagLink {
          attributes {
            href
            rel
          }
        }
        ... on MetaTagContent {
          attributes {
            content
            name
          }
        }
      }

[niknak88]

Hello,

@dottodot can you please show me your addFieldResolver ?

Thanks

[dottodot]

@niknak88 Yes to add to an Event node for example I have

        $registry->addFieldResolver(
            'Event', 'metatags',
            $builder->compose(
                $builder->produce('meta_tag')
                    ->map('type', $builder->fromValue('entity:node'))
                    ->map('value', $builder->fromParent())
            )
        );

[jmolivas]

For the record $path value changed from metatag_normalized to metatag

[jmolivas]

Also full src/Plugin/GraphQL/DataProducer/Field/FieldMetaTag.php file plugin code used on the GraphQL Compose module, including use statements

<?php

namespace Drupal\graphql_compose\Plugin\GraphQL\DataProducer\Field;

use Symfony\Component\DependencyInjection\ContainerInterface;
use Drupal\Core\Render\RenderContext;
use Drupal\Core\Render\BubbleableMetadata;
use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
use Drupal\Core\Render\RendererInterface;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Drupal\Core\TypedData\TypedDataTrait;
use Drupal\Core\TypedData\TypedDataInterface;
use Drupal\typed_data\DataFetcherTrait;
use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;

/**
 * Generates the metatags.
 *
 * @DataProducer(
 *   id = "meta_tag",
 *   name = @Translation("Metatag"),
 *   description = @Translation("return metatags."),
 *   produces = @ContextDefinition("string",
 *     label = @Translation("Path")
 *   ),
 *   consumes = {
 *     "value" = @ContextDefinition("any",
 *       label = @Translation("Root value")
 *     ),
 *     "type" = @ContextDefinition("string",
 *       label = @Translation("Root type"),
 *       required = FALSE
 *     )
 *   }
 * )
 */

class FieldMetaTag extends DataProducerPluginBase implements ContainerFactoryPluginInterface
{
    use TypedDataTrait;
    use DataFetcherTrait;

     /**
      * The rendering service.
      *
      * @var \Drupal\Core\Render\RendererInterface
      */
    protected $renderer;

    /**
     * {@inheritdoc}
     *
     * @codeCoverageIgnore
     */
    public static function create(ContainerInterface $container, array $configuration, $pluginId, $pluginDefinition)
    {
        return new static(
            $configuration,
            $pluginId,
            $pluginDefinition,
            $container->get('renderer')
        );
    }

    /**
     * MetaTag constructor.
     *
     * @param array                                 $configuration
     *   The plugin configuration array.
     * @param string                                $pluginId
     *   The plugin id.
     * @param mixed                                 $pluginDefinition
     *   The plugin definition.
     * @param \Drupal\Core\Render\RendererInterface $renderer
     *   The renderer service.
     *
     * @codeCoverageIgnore
     */
    public function __construct(
        array $configuration,
        $pluginId,
        $pluginDefinition,
        RendererInterface $renderer
    ) {
        parent::__construct($configuration, $pluginId, $pluginDefinition);
        $this->renderer = $renderer;
    }
    /**
     * Resolver.
     *
     * @param mixed                                                    $value
     * @param string|null                                              $type
     * @param \Drupal\Core\Cache\RefinableCacheableDependencyInterface $metadata
     *
     * @return mixed
     */
    public function resolve($value, $type, RefinableCacheableDependencyInterface $metadata)
    {

        if (!($value instanceof TypedDataInterface) && !empty($type)) {
            $manager = $this->getTypedDataManager();
            $definition = $manager->createDataDefinition($type);
            $value = $manager->create($definition, $value);
        }

        if (!($value instanceof TypedDataInterface)) {
            throw new \BadMethodCallException('Could not derive typed data type.');
        }

        $context = new RenderContext();
        $path = 'metatag';
        $bubbleable = new BubbleableMetadata();
        $fetcher = $this->getDataFetcher();

        $result = $this->renderer->executeInRenderContext(
            $context, function () use ($fetcher, $value, $path, $bubbleable) {

                $output = $fetcher->fetchDataByPropertyPath(
                    $value,
                    $path,
                    $bubbleable
                )->getValue();

                return $output;
            }
        );

        if (!$context->isEmpty()) {
            $metadata->addCacheableDependency($context->pop());
        }

        return $result;
    }

}

Latest patch applied https://www.drupal.org/files/issues/2022-10-13/metatag-data-type-support-2945817-154.patch

[ayalon]

We have implemented Metatag support in our new schema generator module for GraphQL 4 here:
https://www.drupal.org/project/graphql_core_schema/

You can enable the related submodule.