@amazeelabs/silverback-gatsby 3.7.13

package/drupal/silverback_gatsby/src/GatsbyBuildTrigger.php

@@ -0,0 +1,230 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Messenger\MessengerInterface;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\graphql\Entity\ServerInterface;
+use GuzzleHttp\Client;
+use GuzzleHttp\Cookie\CookieJar;
+use GuzzleHttp\Exception\GuzzleException;
+use GuzzleHttp\RequestOptions;
+
+class GatsbyBuildTrigger implements GatsbyBuildTriggerInterface {
+
+  use StringTranslationTrait;
+
+  protected array $buildIds = [];
+  protected Client $httpClient;
+  protected MessengerInterface $messenger;
+  protected EntityTypeManagerInterface $entityTypeManager;
+
+  /**
+   * GatsbyBuildTriggerDecorator constructor.
+   *
+   * @param \GuzzleHttp\Client $httpClient
+   * @param \Drupal\Core\Messenger\MessengerInterface $messenger
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManager
+   */
+  public function __construct(
+    Client $httpClient,
+    MessengerInterface $messenger,
+    EntityTypeManagerInterface $entityTypeManager
+  ) {
+    $this->messenger = $messenger;
+    $this->httpClient = $httpClient;
+    $this->entityTypeManager = $entityTypeManager;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function trigger(string $server, int $id) : void {
+    // Make sure the shutdown function is registered only once.
+    if (!$this->buildIds) {
+      drupal_register_shutdown_function([$this, 'sendUpdates']);
+    }
+    if ($url = $this->getWebhook($server)) {
+      $this->buildIds[$url] = $id;
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function triggerLatestBuild(string $server) : TranslatableMarkup {
+    $message = $this->t('No server found with id @server_id.', [
+      '@server_id' => $server,
+    ]);
+
+    $servers = $this->entityTypeManager
+      ->getStorage('graphql_server')
+      ->loadByProperties(['name' => $server]);
+
+    if (empty($servers)) {
+      $message = $this->t('No server found with id @server_id.', [
+        '@server_id' => $server,
+      ]);
+      $this->messenger->addError($message);
+      return $message;
+    }
+
+    $serverEntity = reset($servers);
+    if ($serverEntity instanceof ServerInterface && is_string($serverEntity->id())) {
+      // No dependency injection, prevent circular reference.
+      /** @var \Drupal\silverback_gatsby\GatsbyUpdateTrackerInterface $updateTracker */
+      $updateTracker = \Drupal::service('silverback_gatsby.update_tracker');
+      $latestBuildId = $updateTracker->latestBuild($serverEntity->id());
+      if (!$this->isFrontendLatestBuild($latestBuildId, $serverEntity)) {
+        $message = $this->t('Triggering a build for server @server_id.', [
+          '@server_id' => $server,
+        ]);
+        $this->messenger->addStatus($message);
+        $this->trigger($serverEntity->id(), $latestBuildId);
+      }
+      else {
+        $message = $this->t('Build is already up-to-date for server @server_id.', [
+          '@server_id' => $server,
+        ]);
+        $this->messenger->addStatus($message);
+      }
+    }
+
+    return $message;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function triggerDefaultServerLatestBuild() : TranslatableMarkup {
+    $servers = $this->entityTypeManager->getStorage('graphql_server')->loadMultiple();
+    $silverbackGatsbyServers = array_filter($servers, function (ServerInterface $server) {
+      $configuration = $server->get('schema_configuration')[$server->get('schema')];
+      return !empty($configuration['extensions']['silverback_gatsby']);
+    });
+    $silverbackGatsbyServer = reset($silverbackGatsbyServers);
+
+    if ($silverbackGatsbyServer instanceof ServerInterface && is_string($silverbackGatsbyServer->id())) {
+      return $this->triggerLatestBuild($silverbackGatsbyServer->id());
+    }
+
+    $message = $this->t('No default server found.');
+    $this->messenger->addError($message);
+    return $message;
+  }
+
+  /**
+   * Check on the frontend if the latest build already occurred.
+   *
+   * If the build url is not configured, presume false so the build
+   * will still happen.
+   *
+   * @param int $latestBuildId
+   *   The latest build id.
+   * @param \Drupal\graphql\Entity\ServerInterface $serverEntity
+   *
+   * @return bool
+   *   Whether the frontend is already up-to-date.
+   *
+   * @throws \GuzzleHttp\Exception\GuzzleException
+   */
+  protected function isFrontendLatestBuild(int $latestBuildId, ServerInterface $serverEntity): bool {
+    $result = FALSE;
+    $configuration = $serverEntity->get('schema_configuration')[$serverEntity->get('schema')];
+    if (!empty($configuration['build_url'])) {
+      $buildJsonUrl = $configuration['build_url'] . '/build.json';
+      $httpOptions = [
+        RequestOptions::HTTP_ERRORS => FALSE,
+        RequestOptions::COOKIES => new CookieJar(),
+      ];
+      $response = $this->httpClient->get($buildJsonUrl, $httpOptions);
+      if (
+        $response->getStatusCode() === 401 &&
+        !empty($configuration['build_url_netlify_password'])
+      ) {
+        $response = $this->httpClient->post($buildJsonUrl, $httpOptions + [
+          RequestOptions::FORM_PARAMS => [
+            'password' => $configuration['build_url_netlify_password'],
+          ],
+        ]);
+      }
+      if ($response->getStatusCode() === 200) {
+        $contents = $response->getBody()->getContents();
+
+        if (empty($contents)) {
+          return FALSE;
+        }
+
+        $content = json_decode($contents, TRUE);
+        $buildId = array_key_exists('drupalBuildId', $content) ? (int) $content['drupalBuildId'] : 0;
+        $result = $latestBuildId === $buildId;
+      }
+    }
+    return $result;
+  }
+
+  /**
+   * Get the webhook URL for a server.
+   *
+   * @param string $server_id
+   *   The server id.
+   *
+   * @return mixed|null
+   *   The webhook URL or NULL.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\InvalidPluginDefinitionException
+   * @throws \Drupal\Component\Plugin\Exception\PluginNotFoundException
+   */
+  protected function getWebhook(string $server_id): mixed {
+    $server = $this->entityTypeManager
+      ->getStorage('graphql_server')
+      ->load($server_id);
+
+    if (!$server instanceof ServerInterface) {
+      return NULL;
+    }
+
+    $schema_id = $server->get('schema');
+
+    if (isset($server->get('schema_configuration')[$schema_id]['build_webhook'])) {
+      return $server->get('schema_configuration')[$schema_id]['build_webhook'];
+    }
+
+    return NULL;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function sendUpdates() : void {
+    foreach ($this->buildIds as $url => $id) {
+      try {
+        $this->httpClient->post($url, [
+          'headers' => [
+            // We have to pretend not to be Drupal, or Gatsby cloud will
+            // apply "magic" that causes it not to re-run our sourceNodes
+            // function.
+            'User-Agent' => 'CMS',
+          ],
+          'json' => ['buildId' => $id],
+          // It can happen that a request hangs for too long time.
+          'timeout' => 2,
+        ]);
+        if (
+          function_exists('_gatsby_build_monitor_state') &&
+          // This detects the "build" webhook.
+          str_contains($url, '/data_source/publish/')
+        ) {
+          _gatsby_build_monitor_state('building');
+        }
+      }
+      catch (\Exception | GuzzleException $exc) {
+        $this->messenger->addError('Could not send build notification to server "' . $url . '".');
+        $this->messenger->addError($exc->getMessage());
+      }
+    }
+  }
+
+}

package/drupal/silverback_gatsby/src/GatsbyBuildTriggerInterface.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+
+interface GatsbyBuildTriggerInterface {
+
+  /**
+   * Trigger a build for a given server with a build id.
+   *
+   * @param string $server
+   *   The server id.
+   * @param int $id
+   *   The build id.
+   */
+  public function trigger(string $server, int $id) : void;
+
+  /**
+   * Trigger a build for a given server based on latest build id.
+   *
+   * Compares the latest build id with the one on the frontend to not
+   * trigger unnecessary builds.
+   *
+   * @param string $server
+   *   The server id.
+   *
+   * @return TranslatableMarkup
+   *   The result message.
+   */
+  public function triggerLatestBuild(string $server) : TranslatableMarkup;
+
+  /**
+   * Trigger a build for the default server.
+   *
+   * The default server is selected based on the enabled silverback_gatsby
+   * extension. If there are multiple, the first one is selected.
+   *
+   * Compares the latest build id with the one on the frontend to not
+   * trigger unnecessary builds.
+   *
+   * @return \Drupal\Core\StringTranslation\TranslatableMarkup
+   *   The result message.
+   */
+  public function triggerDefaultServerLatestBuild() : TranslatableMarkup;
+
+  /**
+   * Send out notifications about potential updates to all Gatsby servers.
+   */
+  public function sendUpdates() : void;
+
+}

package/drupal/silverback_gatsby/src/GatsbyUpdate.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+/**
+ * Class GatsbyUpdate
+ *
+ * Simple struct to represent a Gatsby update event.
+ *
+ * @package Drupal\silverback_gatsby
+ */
+class GatsbyUpdate {
+
+  /**
+   * @var string $type
+   *   The GraphQL type that was updated.
+   */
+  public string $type;
+
+  /**
+   * @var string $id
+   *   The GraphQL object id that was updated.
+   */
+  public string $id;
+
+  /**
+   * GatsbyUpdate constructor.
+   *
+   * @param string $type
+   *   The GraphQL type name.
+   * @param string $id
+   *   The GraphQL object id.
+   */
+  public function __construct(string $type, string $id) {
+    $this->type = $type;
+    $this->id = $id;
+  }
+}

package/drupal/silverback_gatsby/src/GatsbyUpdateHandler.php

@@ -0,0 +1,181 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\graphql_directives\Plugin\GraphQL\Schema\DirectableSchema;
+use Drupal\silverback_gatsby\Plugin\GraphQL\SchemaExtension\SilverbackGatsbySchemaExtension;
+use Drupal\user\Entity\User;
+
+/**
+ * Class GatsbyUpdateHandler
+ *
+ * Handle update events from different sources, process and distribute them.
+ *
+ * @package Drupal\silverback_gatsby
+ */
+class GatsbyUpdateHandler {
+
+  /**
+   * @var array<array{
+   *    account: \Drupal\user\UserInterface,
+   *    feeds: array<\Drupal\silverback_gatsby\Plugin\FeedInterface>,
+   *    serverId: string,
+   *    trigger: bool
+   *  }>|null
+   * @internal
+   */
+  public ?array $schemaCache = NULL;
+
+  protected EntityTypeManagerInterface $entityTypeManager;
+  protected GatsbyUpdateTrackerInterface $gatsbyUpdateTracker;
+  protected GatsbyUpdateTriggerInterface $gatsbyUpdateTrigger;
+
+  public function __construct(
+    EntityTypeManagerInterface $entityTypeManager,
+    GatsbyUpdateTrackerInterface $gatsbyUpdateTracker,
+    GatsbyUpdateTriggerInterface $gatsbyUpdateTrigger
+  ) {
+    $this->entityTypeManager = $entityTypeManager;
+    $this->gatsbyUpdateTracker = $gatsbyUpdateTracker;
+    $this->gatsbyUpdateTrigger = $gatsbyUpdateTrigger;
+  }
+
+  /**
+   * Handle an update event.
+   *
+   * @param string $feedClassName
+   *   The feed class name.
+   * @param $context
+   *   The context value.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\InvalidPluginDefinitionException
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   * @throws \Drupal\Component\Plugin\Exception\PluginNotFoundException
+   * @throws \GraphQL\Error\SyntaxError
+   */
+  public function handle(string $feedClassName, $context) {
+    foreach ($this->getSchemas() as $schema) {
+      foreach ($schema['feeds'] as $feed) {
+        if (
+          $feed instanceof $feedClassName
+        ) {
+          // Updates for the actual build. They should respect access
+          // permissions of the configured account.
+          if ($updates = $feed->investigateUpdate($context, $schema['account'])) {
+            foreach ($updates as $update) {
+              $this->gatsbyUpdateTracker->track(
+                $schema['serverId'],
+                $update->type,
+                $update->id,
+                $schema['trigger'],
+              );
+            }
+          }
+          // Preview change notifications should always go through.
+          if ($changes = $feed->investigateUpdate($context, null)) {
+            foreach ($changes as $change) {
+              $this->gatsbyUpdateTrigger->trigger(
+                $schema['serverId'],
+                $change
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * @return array<array{
+   *   account: \Drupal\user\UserInterface,
+   *   feeds: array<\Drupal\silverback_gatsby\Plugin\FeedInterface>,
+   *   serverId: string,
+   *   trigger: bool
+   * }>|null
+   */
+  protected function getSchemas(): array {
+    if ($this->schemaCache !== NULL) {
+      return $this->schemaCache;
+    }
+    $this->schemaCache = [];
+
+    /** @var \Drupal\graphql\Entity\ServerInterface[] $servers */
+    $servers = $this->entityTypeManager
+      ->getStorage('graphql_server')
+      ->loadMultiple();
+
+    $manager = \Drupal::service('plugin.manager.graphql.schema');
+
+    /** @var \Drupal\graphql\Plugin\SchemaPluginInterface $plugin */
+    foreach($servers as  $server) {
+      $schema_id = $server->get('schema');
+      $schema = $manager->createInstance($schema_id);
+      if ($schema instanceof DirectableSchema && $config = $server->get('schema_configuration')) {
+        if (!isset($config[$schema_id]['build_webhook'])) {
+          continue;
+        }
+        $schema->setConfiguration($config[$schema_id] ?? []);
+
+        /**
+         * @var array{
+         *   account: \Drupal\user\UserInterface,
+         *   feeds: array<\Drupal\silverback_gatsby\Plugin\FeedInterface>,
+         *   serverId: string,
+         *   trigger: bool
+         * } $item
+         * */
+        $item = [];
+
+        if ($config[$schema_id]['user'] ?? NULL) {
+          $accounts = $this->entityTypeManager->getStorage('user')->loadByProperties(['uuid' => $config[$schema_id]['user']]);
+          $account = reset($accounts);
+          if (!$account) {
+            if (!getenv('SB_SETUP')) {
+              \Drupal::messenger()->addError("The website won't be rebuilt because of a misconfigured GraphQL server (missing user)");
+              \Drupal::logger('silverback_gatsby')->error('Cannot load user "{user}" configured in server "{server}".', [
+                'user' => $config[$schema_id]['user'],
+                'server' => $server->id(),
+              ]);
+            }
+            return $this->schemaCache;
+          }
+        }
+        else {
+          // This is deprecated. It causes issues with the domain module:
+          // https://github.com/AmazeeLabs/silverback-mono/issues/928
+          $account = User::create();
+          if (isset($config[$schema_id]['role'])) {
+            $account->addRole($config[$schema_id]['role']);
+          }
+        }
+        $item['account'] = $account;
+
+        $item['serverId'] = $server->id();
+
+        // If the configuration is not set, assume TRUE.
+        $trigger = TRUE;
+        if (array_key_exists('build_trigger_on_save', $config[$schema_id])) {
+          $trigger = $config[$schema_id]['build_trigger_on_save'] === 1;
+        }
+        $item['trigger'] = $trigger;
+
+        $item['feeds'] = [];
+        $extensions = $schema->getExtensions();
+        $ast = $schema->getSchemaDocument($extensions);
+        foreach ($extensions as $extension) {
+          if ($extension instanceof SilverbackGatsbySchemaExtension) {
+            foreach ($extension->getFeeds($ast) as $feed) {
+              $item['feeds'][] = $feed;
+            }
+          }
+        }
+
+        $this->schemaCache[] = $item;
+      }
+    }
+
+    return $this->schemaCache;
+  }
+
+}

package/drupal/silverback_gatsby/src/GatsbyUpdateTracker.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Session\AccountInterface;
+
+/**
+ * Class GatsbyUpdateTracker
+ *
+ * Track, store and retrieve updates that happened concerning
+ *
+ * @package Drupal\silverback_gatsby
+ */
+class GatsbyUpdateTracker implements GatsbyUpdateTrackerInterface {
+  protected Connection $database;
+  protected AccountInterface $currentUser;
+  protected GatsbyBuildTriggerInterface $trigger;
+  protected array $tracked;
+
+  public function __construct(
+    Connection $database,
+    AccountInterface $currentUser,
+    GatsbyBuildTriggerInterface $trigger
+  ) {
+    $this->tracked = [];
+    $this->database = $database;
+    $this->currentUser = $currentUser;
+    $this->trigger = $trigger;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function clear() : void {
+    $this->tracked = [];
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function track(string $server, string $type, string $id, bool $trigger = TRUE) : int {
+    if (isset($this->tracked[$server]) && isset($this->tracked[$server][$type]) && in_array($id,$this->tracked[$server][$type])) {
+      return $this->latestBuild($server);
+    }
+    $this->tracked[$server][$type][] = $id;
+    $buildId = $this->database->insert('gatsby_update_log')->fields([
+      'server' => $server,
+      'type' => $type,
+      'object_id' => $id,
+      'uid' => $this->currentUser->id(),
+      'timestamp' => time(),
+    ])->execute();
+    if ($trigger) {
+      $this->trigger->trigger($server, $buildId);
+    }
+    return $buildId;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function diff(int $lastBuild, int $currentBuild, string $server) : array {
+    $count = intval($this->database->select('gatsby_update_log', 'gul')
+      ->condition('server', $server)
+      ->condition('id', [$lastBuild, $currentBuild], 'IN')
+      ->countQuery()
+      ->execute()
+      ->fetchField());
+
+    // If either of the two builds does not exist, we can't be sure about
+    // history consistency and return an empty list which will trigger a full
+    // rebuild.
+    if ($count < 2) {
+      return [];
+    }
+
+    return array_map(fn ($row) => new GatsbyUpdate($row->type, $row->object_id), $this->database
+      ->select('gatsby_update_log', 'gul')
+      ->fields('gul', ['type', 'object_id'])
+      ->condition('id', $lastBuild, '>')
+      ->condition('id', $currentBuild, '<=')
+      ->condition('server', $server)
+      ->distinct()
+      ->execute()
+      ->fetchAll());
+  }
+
+  /**
+   * {@inheritDoc}}
+   */
+  public function latestBuild(string $server) : int {
+    $query = $this->database->select('gatsby_update_log');
+    $query->condition('server', $server);
+    $query->addExpression('max(id)');
+    return $query->execute()->fetchField() ?: -1;
+  }
+}

package/drupal/silverback_gatsby/src/GatsbyUpdateTrackerInterface.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Drupal\silverback_gatsby;
+
+interface GatsbyUpdateTrackerInterface {
+
+  /**
+   * Clear the in-memory de-duplication cache.
+   *
+   * Mainly used for unit testing.
+   */
+  public function clear() : void;
+
+  /**
+   * Track an update for a given GraphQL object.
+   *
+   * @param string $server
+   *   The GraphQL server ID this log is related to.
+   * @param string $type
+   *   The GraphQL type that has changed.
+   * @param string $id
+   *   The id of the changed stream entry.
+   *
+   * @return int
+   *   The unique build id for this entry.
+   *
+   * @throws \Exception
+   */
+  public function track(string $server, string $type, string $id) : int;
+
+  /**
+   * Retrieve the changes that happened between the last and the current build.
+   *
+   * @param int $lastBuild
+   *   The last successful build id as returned by `log`.
+   * @param int $currentBuild
+   *   The current build id as returned by `log`.
+   * @param string $server
+   *   The GraphQL server id.
+   *
+   * @return \Drupal\silverback_gatsby\GatsbyUpdate[]
+   *   A list of [GraphQLType, ID] tuples that can be used by the source plugin
+   *   to fetch changes
+   */
+  public function diff(int $lastBuild, int $currentBuild, string $server) : array;
+
+  /**
+   * Retrieve the id of the latest build for a given server..
+   *
+   * Used for comparing states between systems.
+   *
+   * @param string $server
+   *   The server id to retrieve the latest build for.
+   *
+   * @return int
+   */
+  public function latestBuild(string $server) : int;
+}
+