@amazeelabs/silverback-gatsby 3.7.13

package/drupal/silverback_gatsby/src/Plugin/Gatsby/Feed/MenuFeed.php

@@ -0,0 +1,292 @@
+<?php
+
+namespace Drupal\silverback_gatsby\Plugin\Gatsby\Feed;
+
+use Drupal\content_translation\ContentTranslationManagerInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\TranslatableInterface;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\Core\Language\LanguageManagerInterface;
+use Drupal\Core\Menu\MenuLinkTreeElement;
+use Drupal\Core\Menu\MenuLinkTreeInterface;
+use Drupal\Core\Menu\MenuTreeParameters;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\graphql\GraphQL\Execution\FieldContext;
+use Drupal\graphql\GraphQL\Execution\ResolveContext;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql\GraphQL\ResolverRegistryInterface;
+use Drupal\graphql_directives\Plugin\GraphQL\DataProducer\FilterMenuItems;
+use Drupal\silverback_gatsby\Annotation\GatsbyFeed;
+use Drupal\silverback_gatsby\Plugin\FeedBase;
+use Drupal\silverback_gatsby\Plugin\GraphQL\DataProducer\GatsbyBuildId;
+use Drupal\system\Entity\Menu;
+use GraphQL\Deferred;
+use GraphQL\Language\AST\DocumentNode;
+use GraphQL\Type\Definition\ResolveInfo;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Feed plugin that creates Gatsby feeds based on Drupal menus.
+ *
+ * @GatsbyFeed(
+ *   id = "menu"
+ * )
+ */
+class MenuFeed extends FeedBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The target menu id.
+   *
+   * @var string | null
+   */
+  protected $menu_id;
+
+  /**
+   * Internal menu id's. The first one the current user has access to will be
+   * picked.
+   *
+   * @var string[] | null
+   */
+  protected $menu_ids;
+
+  /**
+   * The maximum menu level.
+   *
+   * @var int
+   */
+  protected int $max_level;
+
+  /**
+   * The GraphQL item type used for menu items.
+   *
+   * @var string | null
+   */
+  protected $item_type;
+
+  /**
+   * @var \Drupal\content_translation\ContentTranslationManagerInterface|null
+   */
+  protected ?ContentTranslationManagerInterface $contentTranslationManager;
+
+  /**
+   * @var \Drupal\Core\Language\LanguageManagerInterface
+   */
+  protected LanguageManagerInterface $languageManager;
+
+  /**
+   * @var \Drupal\Core\Menu\MenuLinkTreeInterface
+   */
+  protected MenuLinkTreeInterface $menuLinkTree;
+
+  /**
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected EntityTypeManagerInterface $entityTypeManager;
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function create(
+    ContainerInterface $container,
+    array $configuration,
+    $plugin_id,
+    $plugin_definition
+  ) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->has('content_translation.manager')
+        ? $container->get('content_translation.manager')
+        : NULL,
+      $container->get('menu.link_tree'),
+      $container->get('language_manager'),
+      $container->get('entity_type.manager')
+    );
+  }
+
+  public function __construct(
+    $config,
+    $plugin_id,
+    $plugin_definition,
+    ?ContentTranslationManagerInterface $contentTranslationManager,
+    MenuLinkTreeInterface $menuLinkTree,
+    LanguageManagerInterface $languageManager,
+    EntityTypeManagerInterface $entityTypeManager
+  ) {
+    $this->menu_id = $config['menu_id'] ?? NULL;
+    $this->menu_ids = $config['menu_ids'] ?? NULL;
+    $this->max_level = $config['max_level'] ?? -1;
+    $this->item_type = $config['item_type'] ?? NULL;
+    $this->contentTranslationManager = $contentTranslationManager;
+    $this->menuLinkTree = $menuLinkTree;
+    $this->languageManager = $languageManager;
+    $this->entityTypeManager = $entityTypeManager;
+
+    parent::__construct(
+      $config,
+      $plugin_id,
+      $plugin_definition
+    );
+  }
+
+  /**
+   * Expose the configured max level so it can be used by the schema extension.
+   *
+   * @return int|mixed
+   */
+  public function getMaxLevel() {
+    return $this->max_level;
+  }
+
+  /**
+   * The menu ids to be loaded and negotiated.
+   *
+   * @return string[]
+   */
+  public function menuIds() {
+    $ids = $this->menu_ids ?: [];
+    if ($this->menu_id) {
+      $ids[] = $this->menu_id;
+    }
+    return $ids;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function isTranslatable(): bool {
+    return $this->contentTranslationManager &&
+      $this->contentTranslationManager->isEnabled('menu_link_content', 'menu_link_content');
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function getUpdateIds($context, ?AccountInterface $account) : array {
+    $params = new MenuTreeParameters();
+    if ($this->max_level > 0) {
+      $params->maxDepth = $this->max_level;
+    }
+
+    // Get all menus that are associated with this feed, and pick the first one
+    // the account has access to.
+    /** @var \Drupal\system\Entity\Menu[] $menus */
+    $menus = $this->entityTypeManager->getStorage('menu')->loadMultiple($this->menuIds());
+    $relevantMenu = NULL;
+    foreach($menus as $menu) {
+      if (!$account || $menu->access('view label', $account)) {
+        $relevantMenu = $menu;
+        break;
+      }
+    }
+
+    if (!$relevantMenu) {
+      return [];
+    }
+
+    $tree = $this->menuLinkTree->load($relevantMenu->id(), $params);
+    $items = FilterMenuItems::flatten($tree, -1);
+
+    $ids = [$context];
+    $match = count(array_filter($items, function (MenuLinkTreeElement $item) use ($ids) {
+      return in_array($item->link->getPluginId(), $ids);
+    })) > 0;
+
+    // If the menu item is not in any exposed menus, don't return any updates.
+    if (!$match) {
+      return [];
+    }
+
+    if ($this->isTranslatable()) {
+      // If menu items are translatable, trigger an update in each language,
+      // since we can't determine easily which language was affected.
+      return array_map(
+        fn (LanguageInterface $lang) =>
+          GatsbyBuildId::build($relevantMenu->id(), $lang->getId())
+        , $this->languageManager->getLanguages());
+    }
+    // Else, simply return the menu id.
+    return [$relevantMenu->id()];
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveItem(ResolverInterface $id, ?ResolverInterface $langcode = null): ResolverInterface {
+    $resolver = $this->builder->produce('entity_load')
+      ->map('type', $this->builder->fromValue('menu'))
+      ->map('id', $id)
+      ->map('access', $this->builder->fromValue(true))
+      ->map('access_operation', $this->builder->fromValue('view label'));
+    if ($this->isTranslatable() && $langcode) {
+      $resolver->map('language', $langcode);
+      $resolver = $this->builder->compose(
+        $this->builder->context('current_menu_language', $langcode),
+        $resolver,
+        $this->builder->callback(function ($value, $args, ResolveContext $context, ResolveInfo $info, FieldContext $fieldContext) {
+          $langcode = $fieldContext->getContextValue('current_menu_language');
+          if ($langcode && $langcode !== $value->language()->getId()) {
+            $clone = clone $value;
+            $clone->set('langcode', $langcode);
+            return $clone;
+          }
+          return $value;
+        })
+      );
+    }
+    return $resolver;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveItems(ResolverInterface $limit, ResolverInterface $offset): ResolverInterface {
+    return $this->builder->produce('entity_load_multiple')
+      ->map('type', $this->builder->fromValue('menu'))
+      ->map('ids', $this->builder->fromValue($this->menuIds()))
+      ->map('access', $this->builder->fromValue(true))
+      ->map('access_operation', $this->builder->fromValue('view label'));
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveId(): ResolverInterface {
+    return $this->builder->produce('entity_id')
+      ->map('entity', $this->builder->fromParent());
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveLangcode(): ResolverInterface {
+    return $this->builder->callback(
+      fn(Menu $value) => $value->language()->getId()
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveDefaultTranslation(): ResolverInterface {
+    return $this->builder->callback(
+      fn(Menu $value) => $value->language()->isDefault()
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveTranslations(): ResolverInterface {
+    return $this->builder->compose($this->builder->callback(function (Menu $menu) {
+      return array_map(function (LanguageInterface $lang) use ($menu) {
+        $clone = clone $menu;
+        $clone->set('langcode', $lang->getId());
+        return $clone;
+      }, $this->languageManager->getLanguages());
+    }));
+  }
+}

package/drupal/silverback_gatsby/src/Plugin/Gatsby/Feed/StringTranslationFeed.php

@@ -0,0 +1,171 @@
+<?php
+
+namespace Drupal\silverback_gatsby\Plugin\Gatsby\Feed;
+
+use Drupal\Core\Session\AccountInterface;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql\GraphQL\ResolverRegistryInterface;
+use Drupal\locale\SourceString;
+use Drupal\locale\StringInterface;
+use Drupal\locale\TranslationString;
+use Drupal\silverback_gatsby\Plugin\FeedBase;
+use GraphQL\Language\AST\DocumentNode;
+
+/**
+ * Feed plugin that creates Gatsby feeds based on Drupal string translations.
+ *
+ * DEPRECATED: Use @translatableString instead, when working with a directive
+ * based schema.
+ *
+ * @GatsbyFeed(
+ *   id = "stringTranslation"
+ * )
+ */
+class StringTranslationFeed extends FeedBase {
+
+  protected $contextPrefix;
+
+  public function __construct(
+    $config,
+    $plugin_id,
+    $plugin_definition
+  ) {
+    $this->contextPrefix = $config['contextPrefix'];
+    parent::__construct($config, $plugin_id, $plugin_definition);
+  }
+
+  public function getTranslationTypeName() {
+    return $this->getTypeName() . 'Translation';
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  function getUpdateIds($context, ?AccountInterface $account): array {
+    if (!$context instanceof StringInterface) {
+      return [];
+    }
+
+    // If the string has the 'context' property, we only return its id if it has
+    // the context prefix match. If there's no context property, then we return
+    // its id in any case.
+    if (!isset($context->context) || empty($this->contextPrefix)) {
+      return [$context->getId()];
+    }
+    if (strpos($context->context, $this->contextPrefix) === 0) {
+      return [$context->getId()];
+    }
+    return [];
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function isTranslatable(): bool {
+    return FALSE;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveId(): ResolverInterface {
+    return $this->builder->produce('string_id')
+      ->map('string', $this->builder->fromParent());
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveLangcode(): ResolverInterface {
+    return $this->builder->callback(
+      fn(StringInterface $value) => $value instanceof TranslationString ? $value->language : ''
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveDefaultTranslation(): ResolverInterface {
+    return $this->builder->callback(
+      fn(StringInterface $value) => FALSE
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveTranslations(): ResolverInterface {
+    return $this->builder->produce('string_translations')
+      ->map('sourceString', $this->builder->fromParent());
+  }
+
+  public function resolveItems(ResolverInterface $limit, ResolverInterface $offset): ResolverInterface {
+    return $this->builder->produce('list_strings')
+      ->map('offset', $this->builder->defaultValue(
+        $this->builder->fromArgument('offset'),
+        $this->builder->fromValue(0)
+      ))
+      ->map('limit', $this->builder->defaultValue(
+        $this->builder->fromArgument('limit'),
+        $this->builder->fromValue(10),
+      ))
+      // For now, the schema extension does not allow array arguments. However,
+      // the list strings resolver can do that, so we just convert the context
+      // prefix to an array here. By doing that, when we add support for array
+      // arguments in directives, we don't have to change this code.
+      ->map('translationContext', $this->builder->fromValue(is_array($this->contextPrefix) ? $this->contextPrefix : [$this->contextPrefix]));
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveItem(ResolverInterface $id, ?ResolverInterface $langcode = null): ResolverInterface {
+    $resolver = $this->builder->produce('fetch_string')
+      ->map('id', $id);
+    return $resolver;
+  }
+
+  public function getExtensionDefinition(DocumentNode $parentAst): string {
+    $typeName = $this->getTypeName();
+    $translationTypeName = $this->getTranslationTypeName();
+    $def = [];
+    $def[] = "extend type $typeName {";
+    $def[] = "  source: String!";
+    $def[] = "  context: String";
+    $def[] = "  translations: [$translationTypeName]";
+    $def[] = "}";
+    $def[] = "type $translationTypeName {";
+    $def[] = "  id: String!";
+    $def[] = "  source: String!";
+    $def[] = "  langcode: String!";
+    $def[] = "  translation: String!";
+    $def[] = "}";
+    return implode("\n", $def);
+  }
+
+  public function addExtensionResolvers(
+    ResolverRegistryInterface $registry,
+    ResolverBuilder $builder
+  ): void {
+    $registry->addFieldResolver($this->getTypeName(), 'source', $builder->callback(
+      fn (StringInterface $value) => $value->getString()
+    ));
+    $registry->addFieldResolver($this->getTypeName(), 'context', $builder->callback(
+      fn (StringInterface $value) => $value->context
+    ));
+    $registry->addFieldResolver($this->getTypeName(), 'translations', $this->resolveTranslations());
+
+    $translationTypeName = $this->getTranslationTypeName();
+    $registry->addFieldResolver($translationTypeName, 'id', $builder->produce('gatsby_build_id')
+      ->map('id', $this->resolveId())
+      ->map('langcode', $this->resolveLangcode()));
+    $registry->addFieldResolver($translationTypeName, 'source', $builder->callback(
+      fn (StringInterface $value) => $value->source
+    ));
+    $registry->addFieldResolver($translationTypeName, 'langcode', $this->resolveLangcode());
+    $registry->addFieldResolver($translationTypeName, 'translation', $builder->callback(
+      fn (StringInterface $value) => $value->getString()
+    ));
+  }
+}

package/drupal/silverback_gatsby/src/Plugin/Gatsby/Feed/TranslatableStringFeed.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace Drupal\silverback_gatsby\Plugin\Gatsby\Feed;
+
+use Drupal\Core\Session\AccountInterface;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\locale\StringInterface;
+use Drupal\locale\TranslationString;
+use Drupal\silverback_gatsby\Plugin\FeedBase;
+
+/**
+ * Feed plugin that sources string translations into Gatsby.
+ *
+ * @GatsbyFeed(
+ *   id = "translatableString"
+ * )
+ */
+class TranslatableStringFeed extends FeedBase {
+
+  /**
+   * The context prefix, matching the drupal translation context.
+   */
+  protected string $contextPrefix;
+
+  /**
+   * {@inheritDoc}
+   */
+  public function __construct(
+    $config,
+    $plugin_id,
+    $plugin_definition
+  ) {
+    $this->contextPrefix = $config['contextPrefix'];
+    parent::__construct($config, $plugin_id, $plugin_definition);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function getUpdateIds($context, ?AccountInterface $account): array {
+    if (!$context instanceof StringInterface) {
+      return [];
+    }
+
+    // If the string has the 'context' property, we only return its id if it has
+    // the context prefix match. If there's no context property, then we return
+    // its id in any case.
+    if (!isset($context->context) || empty($this->contextPrefix)) {
+      return [$context->getId()];
+    }
+    if (strpos($context->context, $this->contextPrefix) === 0) {
+      return [$context->getId()];
+    }
+    return [];
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function isTranslatable(): bool {
+    return TRUE;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveId(): ResolverInterface {
+    return $this->builder->produce('string_id')
+      ->map('string', $this->builder->fromParent());
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveLangcode(): ResolverInterface {
+    return $this->builder->callback(
+      fn(StringInterface $value) => $value instanceof TranslationString ? $value->language : 'en'
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveDefaultTranslation(): ResolverInterface {
+    return $this->builder->callback(
+      fn(StringInterface $value) => FALSE
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveTranslations(): ResolverInterface {
+    return $this->builder->produce('string_translations')
+      ->map('sourceString', $this->builder->fromParent());
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveItems(ResolverInterface $limit, ResolverInterface $offset): ResolverInterface {
+    return $this->builder->produce('list_strings')
+      ->map('offset', $this->builder->defaultValue(
+        $this->builder->fromArgument('offset'),
+        $this->builder->fromValue(0)
+      ))
+      ->map('limit', $this->builder->defaultValue(
+        $this->builder->fromArgument('limit'),
+        $this->builder->fromValue(10),
+      ))
+      // For now, the schema extension does not allow array arguments. However,
+      // the list strings resolver can do that, so we just convert the context
+      // prefix to an array here. By doing that, when we add support for array
+      // arguments in directives, we don't have to change this code.
+      ->map('translationContext', $this->builder->fromValue(is_array($this->contextPrefix) ? $this->contextPrefix : [$this->contextPrefix]));
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function resolveItem(ResolverInterface $id, ?ResolverInterface $langcode = NULL): ResolverInterface {
+    $resolver = $this->builder->produce('fetch_translatable_string')
+      ->map('id', $id)
+      ->map('language', $langcode);
+    return $resolver;
+  }
+
+}

package/drupal/silverback_gatsby/src/Plugin/GraphQL/DataProducer/CurrentUserEntity.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Drupal\silverback_gatsby\Plugin\GraphQL\DataProducer;
+
+use Drupal\Core\Session\AccountProxyInterface;
+use Drupal\graphql\GraphQL\Execution\FieldContext;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\User\CurrentUser;
+use Drupal\user\Entity\User;
+use Drupal\user\UserInterface;
+
+/**
+ * @DataProducer(
+ *   id = "current_user_entity",
+ *   name = @Translation("Current User Entity"),
+ *   description = @Translation("Returns the current authenticated user. Extends the core current_user, to return the User entity instead of the AccountProxy."),
+ *   produces = @ContextDefinition("User",
+ *     label = @Translation("User")
+ *   )
+ * )
+ */
+class CurrentUserEntity extends CurrentUser {
+
+  /**
+   * Returns the current user.
+   *
+   * @param \Drupal\graphql\GraphQL\Execution\FieldContext $field_context
+   *   Field context.
+   *
+   * @return \Drupal\user\UserInterface
+   *   The current user.
+   */
+  public function resolve(FieldContext $field_context): UserInterface {
+    // Response must be cached based on current user as a cache context,
+    // otherwise a new user would become a previous user.
+    $field_context->addCacheableDependency($this->currentUser);
+    $user = NULL;
+    if ($this->currentUser instanceof AccountProxyInterface) {
+      $user = User::load($this->currentUser->id());
+    }
+    return $user;
+  }
+
+}

package/drupal/silverback_gatsby/src/Plugin/GraphQL/DataProducer/EntityQueryBase.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Drupal\silverback_gatsby\Plugin\GraphQL\DataProducer;
+
+use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
+use Drupal\Core\Entity\Query\QueryInterface;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+
+class EntityQueryBase extends DataProducerPluginBase {
+
+  protected function getQuery(string $type, RefinableCacheableDependencyInterface $metadata): QueryInterface {
+    $currentUser = \Drupal::currentUser();
+    $entityType = \Drupal::entityTypeManager()->getDefinition($type);
+
+    $query = \Drupal::entityQuery($type)
+      ->currentRevision()
+      ->accessCheck();
+
+    // Add access conditions. Because accessCheck() does nothing by default. For
+    // example it does not filter out unpublished nodes for anonymous users.
+    // Special permission for nodes.
+    if ($type === 'node' && !$currentUser->hasPermission('bypass node access')) {
+      $query->condition('status', 1);
+    }
+    // Admin permission for other entity types.
+    if (
+      ($publishedKey = $entityType->getKey('published')) &&
+      ($adminPermission = $entityType->getAdminPermission()) &&
+      !$currentUser->hasPermission($adminPermission)
+    ) {
+      $query->condition($publishedKey, 1);
+    }
+
+    $metadata->addCacheTags($entityType->getListCacheTags());
+    $metadata->addCacheContexts($entityType->getListCacheContexts());
+
+    return $query;
+  }
+
+}