@amazeelabs/silverback-gatsby 3.7.13

package/drupal/silverback_gatsby/src/Plugin/GraphQL/SchemaExtension/SilverbackGatsbySchemaExtension.php

@@ -0,0 +1,384 @@
+<?php
+
+namespace Drupal\silverback_gatsby\Plugin\GraphQL\SchemaExtension;
+
+use Drupal\Component\Plugin\PluginManagerInterface;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\TranslatableInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\graphql\GraphQL\Execution\ResolveContext;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql\GraphQL\ResolverRegistry;
+use Drupal\graphql\GraphQL\ResolverRegistryInterface;
+use Drupal\graphql_directives\DirectableSchemaExtensionPluginBase;
+use Drupal\silverback_gatsby\Plugin\FeedInterface;
+use GraphQL\Language\AST\DocumentNode;
+use GraphQL\Language\AST\ListValueNode;
+use GraphQL\Language\AST\ObjectTypeDefinitionNode;
+use GraphQL\Language\AST\StringValueNode;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Schema extension plugin that prepares any schema to be consumed by Gatsby.
+ *
+ * @SchemaExtension(
+ *   id = "silverback_gatsby",
+ *   name = "Silverback Gatsby",
+ *   description = "Schema extension providing default resolvers for Gatsby."
+ * )
+ */
+class SilverbackGatsbySchemaExtension extends DirectableSchemaExtensionPluginBase
+{
+
+  /**
+   * The list of feeds that are used by the parent schema.
+   *
+   * @var array
+   */
+  protected array $feeds = [];
+
+  /**
+   * The list of fields marked with "resolve*" directives.
+   *
+   * @var array
+   *   Keys are GraphQL paths, values are directive names and arguments.
+   *   Example:
+   *   [
+   *     'Page.path' => [
+   *       'name' => 'resolvePath',
+   *       'arguments' => [],
+   *     ],
+   *     'Page.title' => [
+   *       'name' => 'resolveProperty',
+   *       'arguments' => ['path' => 'title.value'],
+   *     ]
+   *   ]
+   */
+  protected array $resolvers;
+
+  /**
+   * @var \Drupal\Core\Plugin\DefaultPluginManager|object|null
+   */
+  protected $feedManager;
+
+  /**
+   * @var \Psr\Log\LoggerInterface
+   */
+  protected $logger;
+
+
+  /**
+   * {@inheritdoc}
+   *
+   * @codeCoverageIgnore
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition)
+  {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('module_handler'),
+      $container->get('silverback_gatsby.feed_manager'),
+      $container->get('logger.factory')->get('silverback_gatsby'),
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function __construct(
+    array $configuration,
+    $pluginId,
+    array $pluginDefinition,
+    ModuleHandlerInterface $moduleHandler,
+    PluginManagerInterface $feedManager,
+    LoggerInterface $logger
+  ) {
+    parent::__construct(
+      $configuration,
+      $pluginId,
+      $pluginDefinition,
+      $moduleHandler,
+    );
+    $this->feedManager = $feedManager;
+    $this->logger = $logger;
+  }
+
+  public function getBaseDefinition() {
+    return implode("\n", [
+      $this->getDirectiveDefinitions(),
+      parent::getBaseDefinition(),
+    ]);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function getDirectiveDefinitions(): string
+  {
+    $feeds = $this->feedManager->getDefinitions();
+    uasort($feeds, fn($a, $b) => strnatcasecmp($a['id'], $b['id']));
+    $directives = array_map(fn($def) => $def['directive'], $feeds);
+    return implode("\n", $directives);
+  }
+
+  /**
+   * Retrieve all feeds that are referenced in the host schema.
+   *
+   * @return \Drupal\silverback_gatsby\Plugin\FeedInterface[]
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   */
+  public function getFeeds(DocumentNode $ast): array
+  {
+    if (count($this->feeds) === 0) {
+      // Search for object type definitions ...
+      foreach ($ast->definitions->getIterator() as $definition) {
+        // ... that have directives.
+        if ($definition instanceof ObjectTypeDefinitionNode && $definition->directives) {
+          // Create feed instances for all directives that are know to the
+          // feed manager.
+          foreach ($definition->directives->getIterator() as $directive) {
+            /** @var \GraphQL\Language\AST\DirectiveNode $directive */
+            $id = $directive->name->value;
+            if (!$this->feedManager->hasDefinition($id)) {
+              continue;
+            }
+
+            // Collect the type name.
+            $config = [
+              'typeName' => $definition->name->value,
+            ];
+
+            // Collect the directive arguments.
+            foreach ($directive->arguments->getIterator() as $arg) {
+              /** @var \GraphQL\Language\AST\ArgumentNode $arg */
+              if ($arg->value instanceof ListValueNode) {
+                // If it's a list value, turn it into an array of values.
+                $config[$arg->name->value] = [];
+                for ($i = 0; $i < $arg->value->values->count(); $i++) {
+                  if ($arg->value->values[$i] instanceof StringValueNode) {
+                    $config[$arg->name->value][] = $arg->value->values[$i]->value;
+                  }
+                }
+              } else {
+                $config[$arg->name->value] = $arg->value->value;
+              }
+            }
+
+            // Collect the field directives.
+            /** @var \GraphQL\Language\AST\FieldDefinitionNode $field */
+            foreach ($definition->fields as $field) {
+              foreach ($field->directives as $fieldDirective) {
+
+                // Directives used for automatic page creation.
+                if (in_array($fieldDirective->name->value, ['isPath', 'path'], TRUE)) {
+                  $config['createPageFields']['isPath'] = $field->name->value;
+                }
+                if (in_array($fieldDirective->name->value, ['isTemplate', 'template'], TRUE)) {
+                  $config['createPageFields']['isTemplate'] = $field->name->value;
+                }
+              }
+            }
+
+            $this->feeds[] = $this->feedManager->createInstance($id, $config);
+          }
+        }
+      }
+    }
+    return $this->feeds;
+  }
+
+  /**
+   * Build the automatic schema definition for a given Feed.
+   */
+  protected function getSchemaDefinitions(DocumentNode $ast, FeedInterface $feed): string
+  {
+    $typeName = $feed->getTypeName();
+    $singleFieldName = $feed->getSingleFieldName();
+    $listFieldName = $feed->getListFieldName();
+    $schema = [
+      "extend type Query {",
+      "  $singleFieldName(id: String!): $typeName @deprecated",
+      "  $listFieldName(offset: Int, limit: Int): [$typeName]! @deprecated",
+    ];
+
+    $schema[] = "}";
+
+    if ($feed->isTranslatable()) {
+      $schema[] = "extend type $typeName {";
+      $schema[] = "  _id: String! @deprecated";
+      $schema[] = "  _drupalId: String! @deprecated";
+      $schema[] = "  _defaultTranslation: Boolean! @deprecated";
+      $schema[] = "  _langcode: String! @deprecated";
+      $schema[] = "  _translations: [$typeName!]! @deprecated";
+      $schema[] = "}";
+    } else {
+      $schema[] = "extend type $typeName {";
+      $schema[] = "  _id: String! @deprecated";
+      $schema[] = "  _drupalId: String! @deprecated";
+      $schema[] = "}";
+    }
+
+    $schema[] = $feed->getExtensionDefinition($ast);
+
+    return implode("\n", $schema);
+  }
+
+  protected function getDirectableExtensionDefinition(DocumentNode $ast): string {
+    // Collect all active feeds and prepend their definitions to the schema.
+    $schema = array_map(fn(FeedInterface $feed) => $this->getSchemaDefinitions($ast, $feed), $this->getFeeds($ast));
+    array_unshift($schema, $this->getOriginalTypenameDefinitions($ast));
+    return implode("\n", $schema);
+  }
+
+  protected function registerDirectableResolvers(DocumentNode $ast, ResolverRegistryInterface $registry): void
+  {
+    $builder = new ResolverBuilder();
+    $this->addFieldResolvers($ast, $registry, $builder);
+    $this->addOriginalTypenameResolvers($ast, $registry, $builder);
+  }
+
+
+  /**
+   * Attach a _original_typename field to every type.
+   *
+   * To preserve the original type in cases where the types are namespaced and
+   * merged into a different graphql schema (e.g. Gatsby).
+   *
+   * @return string
+   */
+  protected function getOriginalTypenameDefinitions(DocumentNode $ast): string
+  {
+    $types = [];
+    foreach ($ast->definitions->getIterator() as $definition) {
+      if ($definition instanceof ObjectTypeDefinitionNode) {
+        $name = $definition->name->value;
+        $types[] = "extend type {$name} { _original_typename: String! @deprecated }";
+      }
+    }
+    return implode("\n", $types);
+  }
+
+  /**
+   * Attach a _original_typename resolvers.
+   *
+   * @return void
+   */
+  protected function addOriginalTypenameResolvers(DocumentNode $ast, ResolverRegistry $registry, ResolverBuilder $builder)
+  {
+    foreach ($ast->definitions->getIterator() as $definition) {
+      if ($definition instanceof ObjectTypeDefinitionNode) {
+        $registry->addFieldResolver($definition->name->value, '_original_typename', $builder->fromValue($definition->name->value));
+      }
+    }
+  }
+
+  /**
+   * Implement field resolvers for this extension.
+   */
+  protected function addFieldResolvers(DocumentNode $ast, ResolverRegistry $registry, ResolverBuilder $builder)
+  {
+
+    $registry->addFieldResolver(
+      'Query',
+      '_drupalFeedInfo',
+      $builder->fromValue(array_map(fn(FeedInterface $feed) => $feed->info(), $this->getFeeds($ast)))
+    );
+    $registry->addFieldResolver(
+      'Query',
+      '_drupalBuildId',
+      $builder->callback(function ($value, $args, ResolveContext $context) {
+        // Make sure this is never cached.
+        $context->mergeCacheMaxAge(0);
+        /** @var \Drupal\silverback_gatsby\GatsbyUpdateTrackerInterface $tracker */
+        $tracker = \Drupal::service('silverback_gatsby.update_tracker');
+        return $tracker->latestBuild($context->getServer()->id());
+      })
+    );
+
+    $registry->addFieldResolver('_Feed', 'changes', $builder->callback(function ($value, $args, ResolveContext $context) {
+      // Make sure this is never cached.
+      $context->mergeCacheMaxAge(0);
+      /** @var \Drupal\silverback_gatsby\GatsbyUpdateTrackerInterface $tracker */
+      $tracker = \Drupal::service('silverback_gatsby.update_tracker');
+      return array_map(
+        fn($change) => $change->id,
+        array_filter(
+          isset($args['lastBuild']) && isset($args['currentBuild'])
+          ? $tracker->diff($args['lastBuild'], $args['currentBuild'], $context->getServer()->id())
+          : [],
+          fn($change) => $change->type === $value['typeName']
+        )
+      );
+    }));
+
+    foreach ($this->getFeeds($ast) as $feed) {
+
+      $idResolver = $feed->resolveId();
+      $langcodeResolver = $feed->resolveLangcode();
+
+      $registry->addFieldResolver(
+        'Query', $feed->getListFieldName(),
+        $feed->resolveItems(
+          $builder->fromArgument('limit'),
+          $builder->fromArgument('offset'),
+        )
+      );
+
+      $typeName = $feed->getTypeName();
+      $registry->addFieldResolver($typeName, '_drupalId', $idResolver);
+      $feed->addExtensionResolvers($registry, $builder);
+
+      if ($feed->isTranslatable()) {
+        $registry->addFieldResolver(
+          'Query', $feed->getSingleFieldName(),
+          $feed->resolveItem(
+            $builder->produce('gatsby_extract_id')
+              ->map('id', $builder->fromArgument('id')),
+            $builder->produce('gatsby_extract_langcode')
+              ->map('id', $builder->fromArgument('id')),
+          )
+        );
+
+        $registry->addFieldResolver(
+          $typeName,
+          '_id',
+          $builder->produce('gatsby_build_id')
+            ->map('id', $idResolver)
+            ->map('langcode', $langcodeResolver)
+        );
+
+        $registry->addFieldResolver($typeName, '_langcode', $langcodeResolver);
+        $registry->addFieldResolver($typeName, '_defaultTranslation', $feed->resolveDefaultTranslation());
+        $registry->addFieldResolver($typeName, '_translations', $feed->resolveTranslations());
+      }
+      else {
+        $registry->addFieldResolver(
+          'Query', $feed->getSingleFieldName(),
+          $feed->resolveItem(
+            $builder->fromArgument('id')
+          )
+        );
+
+        $registry->addFieldResolver($typeName, '_id', $idResolver);
+      }
+    }
+
+    $addResolver = function (string $path, ResolverInterface $resolver) use ($registry) {
+      [$type, $field] = explode('.', $path);
+      $registry->addFieldResolver($type, $field, $resolver);
+    };
+
+    $currentUser = $builder->produce('current_user_entity');
+    $addResolver('Query._currentUser', $currentUser);
+
+    $entityId = $builder->produce('entity_id')->map('entity', $builder->fromParent());
+    $entityLabel = $builder->callback(fn(EntityInterface $value) => $value->label());
+    $addResolver('_User.id', $entityId);
+    $addResolver('_User.name', $entityLabel);
+  }
+
+}

package/drupal/silverback_gatsby/src/SilverbackGatsbyServiceProvider.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\DependencyInjection\ServiceProviderBase;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Service provider class for the silverback_gatsby module..
+ */
+class SilverbackGatsbyServiceProvider extends ServiceProviderBase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public function alter(ContainerBuilder $container) {
+    // To not introduce a dependency on the locale module, we only decorate the
+    // locale.storage service if the service actually exists, so if the locale
+    // module is enabled.
+    // We also check if the StringContextInterface exists, otherwise most
+    // probably the patch from https://www.drupal.org/node/2123543 was not
+    // applied.
+    if ($container->hasDefinition('locale.storage') && interface_exists('Drupal\locale\StringContextInterface')) {
+      $localeDecoratorDefinition = new Definition();
+      $localeDecoratorDefinition->setClass(LocaleStorageDecorator::class);
+      $localeDecoratorDefinition->setDecoratedService('locale.storage');
+      $localeDecoratorDefinition->setPublic(FALSE);
+      $localeDecoratorDefinition->addArgument(new Reference('silverback_gatsby.locale.storage.inner'));
+      $definitions['silverback_gatsby.locale.storage'] = $localeDecoratorDefinition;
+      $container->addDefinitions($definitions);
+    }
+
+
+    // Swap the session configuration service with a custom one.
+    if ($container->hasDefinition('session_configuration')) {
+      $definition = $container->getDefinition('session_configuration');
+      $definition->setClass('Drupal\silverback_gatsby\SilverbackGatsbySessionConfiguration');
+    }
+
+  }
+}

package/drupal/silverback_gatsby/src/SilverbackGatsbySessionConfiguration.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Drupal\Core\Session\SessionConfiguration;
+use Symfony\Component\HttpFoundation\Request;
+
+/**
+ * Decorator for the core session configuration service.
+ */
+class SilverbackGatsbySessionConfiguration extends SessionConfiguration {
+  /**
+   * Remove X-Forwarded-* headers from the request, so they
+   * don't affect the session name. Otherwise session information
+   * is lost when using a reverse proxy and direct access simultaneously.
+   * 
+   * Use case: User login-in via the backend domain and send requests from
+   * the frontend that include X-Forwarded-* headers to create image urls
+   * with the frontend domain. Without this, the dynamic request would not
+   * be authenticated any more because the session name would be different,
+   * because `$request->getHost()` would return the X-Forwarded-Host.
+   */
+  protected function getUnprefixedName(Request $request) {
+    $cleaned = clone $request;
+    $cleaned->headers->remove('X-Forwarded-Proto');
+    $cleaned->headers->remove('X-Forwarded-Host');
+    $cleaned->headers->remove('X-Forwarded-Port');
+    return parent::getUnprefixedName($cleaned);
+  }
+}

package/drupal/silverback_gatsby/src/SilverbackReverseProxyMiddleware.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+
+/**
+ * Custom reverse proxy middleweare.
+ * 
+ * Rewrites custom reverse proxy headers to standard ones.
+ * Lagoon won't allow X-Forwarded-* headers from unknown proxies
+ * and Netlify does not provide an IP range. Therefore we send
+ * custom SLB-Forwarded-* headers and write them into X-Forwarded-*
+ * using this middleware.
+ */
+class SilverbackReverseProxyMiddleware implements HttpKernelInterface {
+
+  /**
+   * The inner kernel to which the request will be passed.
+   *
+   * @var \Symfony\Component\HttpKernel\HttpKernelInterface
+   */
+  protected $app;
+
+  /**
+   * Constructs a HostChanger object.
+   *
+   * @param \Symfony\Component\HttpKernel\HttpKernelInterface $app
+   *   The inner kernel to which the request will be passed.
+   */
+  public function __construct(HttpKernelInterface $app) {
+    $this->app = $app;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function handle(Request $request, $type = HttpKernelInterface::MAIN_REQUEST, $catch = TRUE): Response {
+    foreach (['Proto', 'Host', 'Port', 'For'] as $header) {
+      if ($request->headers->has('SLB-Forwarded-' . $header)) {
+        $request->headers->set('X-Forwarded-' . $header, $request->headers->get('SLB-Forwarded-' . $header));
+      }
+    }
+    // Pass the request to the next middleware.
+    return $this->app->handle($request, $type, $catch);
+  }
+}

package/drupal/silverback_gatsby/tests/queries/create-page-fields.gql

@@ -0,0 +1,12 @@
+query {
+  regular: _loadPost(id: "1") {
+    title
+    path
+    template
+  }
+  promoted: _loadPost(id: "2") {
+    title
+    path
+    template
+  }
+}

package/drupal/silverback_gatsby/tests/queries/current-user.gql

@@ -0,0 +1,6 @@
+{
+  _currentUser {
+    id
+    name
+  }
+}

package/drupal/silverback_gatsby/tests/queries/feed_info.gql

@@ -0,0 +1,12 @@
+query FeedInfo($lastBuild: Int, $currentBuild: Int) {
+  _drupalBuildId
+  _drupalFeedInfo {
+    typeName
+    translatable
+    singleFieldName
+    listFieldName
+    changes(lastBuild: $lastBuild, currentBuild: $currentBuild)
+    pathFieldName
+    templateFieldName
+  }
+}

package/drupal/silverback_gatsby/tests/queries/load-entity.gql

@@ -0,0 +1,5 @@
+query ($input: String!) {
+  _loadPage(id: $input) {
+    title
+  }
+}

package/drupal/silverback_gatsby/tests/queries/menus.gql

@@ -0,0 +1,31 @@
+query Menus {
+  _queryMainMenus(limit: 10, offset: 0) {
+    __typename
+    _id
+    _drupalId
+  }
+
+  _queryVisibleMainMenus(limit: 10, offset: 0) {
+    __typename
+    _id
+    _drupalId
+  }
+
+  _loadMainMenu(id: "main") {
+    items {
+      id
+      parent
+      label
+      url
+    }
+  }
+
+  _loadVisibleMainMenu(id: "main") {
+    items {
+      id
+      parent
+      label
+      url
+    }
+  }
+}

package/drupal/silverback_gatsby/tests/queries/multilingual-menus.gql

@@ -0,0 +1,11 @@
+query MultilingualMenus {
+  noLanguageDefined: _loadMainMenu(id: "main") {
+    _id
+  }
+  en: _loadMainMenu(id: "main:en") {
+    _id
+  }
+  de: _loadMainMenu(id: "main:de") {
+    _id
+  }
+}

package/drupal/silverback_gatsby/tests/queries/revisionable-translatable.gql

@@ -0,0 +1,15 @@
+query {
+  a: _loadPageRevision(id: "1:en", revision: "1") {
+    title
+  }
+  # This should be null, since the first revision has no german translation.
+  b: _loadPageRevision(id: "1:de", revision: "1") {
+    title
+  }
+  c: _loadPageRevision(id: "1:de", revision: "2") {
+    title
+  }
+  d: _loadPageRevision(id: "1:de", revision: "3") {
+    title
+  }
+}

package/drupal/silverback_gatsby/tests/queries/revisionable.gql

@@ -0,0 +1,8 @@
+query {
+  a: _loadPostRevision(id: "1", revision: "1") {
+    title
+  }
+  b: _loadPostRevision(id: "1", revision: "2") {
+    title
+  }
+}

package/drupal/silverback_gatsby/tests/queries/translatable.gql

@@ -0,0 +1,14 @@
+query ($id: String!) {
+  _loadPage(id: $id) {
+    title
+  }
+  _queryPages {
+    _id
+    _drupalId
+    _translations {
+      _defaultTranslation
+      _langcode
+      title
+    }
+  }
+}

package/drupal/silverback_gatsby/tests/queries/untranslatable.gql

@@ -0,0 +1,10 @@
+query {
+  _loadPost(id: "1") {
+    title
+  }
+  _queryPosts(limit: 10, offset: 0) {
+    _id
+    _drupalId
+    title
+  }
+}

package/drupal/silverback_gatsby/tests/schema/.graphqlrc.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://unpkg.com/graphql-config@5.0.3/config-schema.json",
+  "schema": []
+}

package/drupal/silverback_gatsby/tests/schema/translatable-strings.graphql

@@ -0,0 +1,7 @@
+type Query
+
+type TranslatableString @translatableString(contextPrefix: "gatsby") {
+  source: String!
+  language: String!
+  translation: String
+}