patternkit.install

<?php

/**
 * @file
 * Install file for patternkit module.
 */

use Drupal\Core\Cache\Cache;
use Drupal\Core\Config\FileStorage;
use Drupal\Core\Entity\ContentEntityType;
use Drupal\Core\Entity\EntityAccessControlHandler;
use Drupal\Core\Entity\EntityListBuilder;
use Drupal\Core\Entity\EntityViewBuilder;
use Drupal\Core\Entity\Sql\SqlContentEntityStorage;
use Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\patternkit\BulkOperations\LayoutUpdateBatchManager;
use Drupal\patternkit\Entity\Pattern;
use Drupal\patternkit\Entity\PatternRouteProvider;
use Drupal\patternkit\Form\PatternLibraryJSONForm;
use Drupal\patternkit\Hook\ReusableBlockHooks;
use Drupal\patternkit\Plugin\Block\PatternkitBlock as BlockPatternkitBlock;
use Drupal\patternkit\Plugin\Derivative\PatternkitBlock as DerivativePatternkitBlock;
use Drupal\user\Entity\Role;
use Drupal\user\RoleInterface;
use Drupal\views\EntityViewsData;

/**
 * Implements hook_uninstall().
 */
function patternkit_uninstall(bool $is_syncing): void {
  // Cleanup the update results collection value if it exists.
  \Drupal::keyValue(LayoutUpdateBatchManager::RESULTS_COLLECTION)
    ->deleteAll();
}

/**
 * Implements hook_requirements().
 */
function patternkit_requirements($phase): array {
  $requirements = [];
  if ($phase === 'runtime') {
    /** @var \Drupal\patternkit\Hook\ReusableBlockHooks $hooks */
    $hooks = \Drupal::classResolver(ReusableBlockHooks::class);
    $requirements = $hooks->requirements($phase);
  }

  return $requirements;
}

/**
 * Allows upgrading from dev version automatically.
 *
 * @throws \Drupal\Core\Entity\Exception\EntityTypeIdLengthException
 */
function patternkit_update_8001(&$sandbox) {
  // Installs new entities if necessary.
  $entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
  if (!$entity_definition_update_manager->getEntityType('patternkit_pattern')) {
    $pattern_entity_type = new ContentEntityType([
      'id' => 'patternkit_pattern',
      'class' => Pattern::class,
      'label' => t('Pattern'),
      'label_collection' => t('Pattern Libraries'),
      'label_plural' => t('Patterns'),
      'label_singular' => t('Pattern'),
      'label_count' => [
        'singular' => t('@count patterns'),
        'plural' => t('@count custom blocks'),
      ],
      'admin_permission' => 'administer blocks',
      'base_table' => 'pattern',
      'revision_table' => 'pattern_revision',
      'entity_keys' => [
        'id' => 'id',
        'hash' => 'hash',
        'assets' => 'assets',
        'category' => 'category',
        'label' => 'name',
        'library' => 'library',
        'libraryPluginId' => 'libraryPluginId',
        'path' => 'path',
        'revision' => 'revision',
        'schema' => 'schema',
        'template' => 'template',
        'uuid' => 'uuid',
        'version' => 'version',
      ],
      'revision_metadata_keys' => [
        'revision_default' => 'revision_default',
        'revision_user' => 'revision_user',
        'revision_created' => 'revision_created',
        'revision_log_message' => 'revision_log_message',
      ],
      'handlers' => [
        'access' => EntityAccessControlHandler::class,
        'storage' => SqlContentEntityStorage::class,
        'storage_schema' => SqlContentEntityStorageSchema::class,
        'view_builder' => EntityViewBuilder::class,
        'views_data' => EntityViewsData::class,
        'route_provider' => [
          'html' => PatternRouteProvider::class,
        ],
        'list_builder' => EntityListBuilder::class,
      ],
      'links' => [
        'canonical' => '/patternkit/{patternkit_pattern}',
        'collection' => '/patternkit',
      ],
      'translatable' => FALSE,
    ]);
    $entity_definition_update_manager->installFieldableEntityType($pattern_entity_type, Pattern::baseFieldDefinitions($pattern_entity_type));
  }

  // Upgrades existing patterns.
  /** @var \Drupal\patternkit\UpdateHelper $update_helper */
  $update_helper = \Drupal::service('patternkit.helper.update');
  $update_helper->updateAllPatternComponents();

  // Clears caches.
  $user_caches = [
    'apcu_clear_cache',
    'wincache_ucache_clear',
    'xcache_clear_cache',
    'opcache_reset',
  ];
  array_map('call_user_func', array_filter($user_caches, 'is_callable'));
  foreach (Cache::getBins() as $bin) {
    $bin->deleteAll();
  }
  \Drupal::service('page_cache_kill_switch')->trigger();
  drupal_flush_all_caches();
}

/**
 * Adds proper revision metadata keys to Patternkit.
 */
function patternkit_update_8002(&$sandbox) {
  $entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
  $entity_type = $entity_definition_update_manager->getEntityType('patternkit_pattern');
  $metadata_keys = $entity_type->get('revision_metadata_keys');
  $metadata_keys = is_array($metadata_keys) ? $metadata_keys : [];
  $metadata_keys = [
    'revision_default' => 'revision_default',
    'revision_user' => 'revision_user',
    'revision_created' => 'revision_created',
    'revision_log_message' => 'revision_log_message',
  ] + $metadata_keys;
  $entity_type->set('revision_metadata_keys', $metadata_keys);
  $entity_definition_update_manager->updateEntityType($entity_type);
}

/**
 * Adds reverse lookup pattern id field for Patternkit reusable blocks.
 */
function patternkit_update_8003(&$sandbox) {
  $entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
  $entity_type = $entity_definition_update_manager->getEntityType('patternkit_block');

  $entity_keys = $entity_type->get('entity_keys');
  $entity_keys['pattern'] = 'pattern_id';
  $entity_type->set('entity_keys', $entity_keys);

  $pattern_id_field_definition = BaseFieldDefinition::create('string')
    ->setLabel(t('Patternkit Pattern Derivative ID'))
    ->setDescription(t('The machine name of the Patternkit pattern.'));
  $entity_definition_update_manager
    ->installFieldStorageDefinition('pattern_id',
      'patternkit_block', 'patternkit', $pattern_id_field_definition);
}

/**
 * Sets default values for new json-editor settings.
 */
function patternkit_update_8004(&$sandbox) {
  $config_key = 'patternkit.settings';
  $patternkit_module_path = \Drupal::service('extension.list.module')
    ->getPath('patternkit');
  $source = new FileStorage($patternkit_module_path . '/config/install');
  $config_install = $source->read($config_key);
  $config_current = \Drupal::configFactory()->getEditable($config_key);

  $new_keys = [
    'patternkit_json_editor_use_shadow_dom',
    'patternkit_json_editor_wysiwyg',
    'patternkit_json_editor_ckeditor_toolbar',
  ];
  $changed = FALSE;
  foreach ($new_keys as $new_key) {
    if (is_null($config_current->get($new_key))) {
      $config_current->set($new_key, $config_install[$new_key]);
      $changed = TRUE;
    }
  }

  if ($changed) {
    $config_current->save();
  }
}

/**
 * Sets default value for new JSON Editor schema caching setting.
 */
function patternkit_update_8005(&$sandbox) {
  $config_key = 'patternkit.settings';
  $module_file_path = \Drupal::service('extension.list.module')
    ->getPath('patternkit');
  $source = new FileStorage($module_file_path . '/config/install');
  $config_install = $source->read($config_key);
  $config_current = \Drupal::configFactory()->getEditable($config_key);

  $new_key = 'patternkit_json_editor_cache_schemas';
  if (is_null($config_current->get($new_key))) {
    $config_current->set($new_key, $config_install[$new_key]);
    $config_current->save();
  }
}

/**
 * Adds 'dependencies' field to 'patternkit_pattern' entities.
 */
function patternkit_update_9001(&$sandbox) {
  $field_storage_definition = BaseFieldDefinition::create('string')
    ->setLabel(t('Dependencies'))
    ->setDescription(t('A collection of pattern reference dependencies detected within the Pattern.'))
    ->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);

  \Drupal::entityDefinitionUpdateManager()
    ->installFieldStorageDefinition('dependencies', 'patternkit_pattern', 'patternkit', $field_storage_definition);
}

/**
 * Update Pattern entity properties to be revisionable fields.
 */
function patternkit_update_9002(&$sandbox) {
  $database = \Drupal::database();
  $transaction = $database->startTransaction();

  $entity_type_manager = \Drupal::entityTypeManager();
  $definition_manager = \Drupal::entityDefinitionUpdateManager();

  $storage = $entity_type_manager->getStorage('patternkit_pattern');
  assert($storage instanceof SqlContentEntityStorage);
  $entity_definition = $entity_type_manager->getDefinition('patternkit_pattern');
  $revision_id_key = $entity_definition->getKey('revision');

  // If there is no data table defined then use the base table.
  $table_name = $storage->getDataTable() ?: $storage->getBaseTable();
  $revision_table_name = $storage->getRevisionDataTable() ?: $storage->getRevisionTable();

  $keys = $entity_definition->getKeys();
  unset($keys['hash']);
  unset($keys['schema']);
  unset($keys['template']);
  unset($keys['version']);
  $entity_definition->set('entity_keys', $keys);

  $definition_manager->updateEntityType($entity_definition);

  $fields = [];
  $fields['hash'] = BaseFieldDefinition::create('string')
    ->setLabel(t('Hash'))
    ->setCardinality(1)
    ->setRevisionable(TRUE);
  $fields['schema'] = BaseFieldDefinition::create('string_long')
    ->setLabel(t('Schema'))
    ->setCardinality(1)
    ->setRevisionable(TRUE);
  $fields['template'] = BaseFieldDefinition::create('string_long')
    ->setLabel(t('Template'))
    ->setCardinality(1)
    ->setRevisionable(TRUE);
  $fields['version'] = BaseFieldDefinition::create('string')
    ->setLabel(t('Version'))
    ->setCardinality(1)
    ->setRevisionable(TRUE);

  $original_values = $database->select($table_name)
    ->fields($table_name, [
      $revision_id_key,
      'hash',
      'schema',
      'template',
      'version',
    ])
    ->execute()
    ->fetchAllAssoc($revision_id_key);

  foreach ($fields as $name => $definition) {
    // Install the new definition.
    $definition_manager->installFieldStorageDefinition($name, 'patternkit_pattern', 'patternkit', $definition);
  }

  // Map the original values into the revisions table.
  foreach ($original_values as $id => $values) {
    $database->update($revision_table_name)
      ->fields([
        'hash' => $values->hash,
        'schema' => $values->schema,
        'template' => $values->template,
        'version' => $values->version,
      ])
      ->condition($revision_id_key, $id)
      ->execute();
  }

  unset($transaction);
}

/**
 * Grant user roles new 'administer patternkit' permission.
 */
function patternkit_update_9003() {
  // Grant new permission to user roles that had the previous permission,
  // `access administration pages`, to manage patternkit configuration.
  $permission = 'access administration pages';
  $roles = array_filter(Role::loadMultiple(), fn(RoleInterface $role) => $role->hasPermission($permission));

  foreach ($roles as $role) {
    $role->grantPermission('administer patternkit');
    $role->save();
  }
}

/**
 * Remove deleted shadow dom settings from configuration.
 */
function patternkit_update_9004(): void {
  $removed_settings = [
    'patternkit_json_editor_use_shadow_dom',
  ];

  $config_key = 'patternkit.settings';
  $config = \Drupal::configFactory()->getEditable($config_key);

  if ($config) {
    // Remove each setting from the saved values.
    foreach ($removed_settings as $setting) {
      $config->clear($setting);
    }

    // Save the changes.
    $config->save(TRUE);
  }
}

/**
 * Remove deleted cache usage settings from configuration.
 */
function patternkit_update_9005(): void {
  $removed_settings = [
    'patternkit_cache_enabled',
    'patternkit_render_cache',
  ];

  $config_key = 'patternkit.settings';
  $config = \Drupal::configFactory()->getEditable($config_key);

  if ($config) {
    // Remove each setting from the saved values.
    foreach ($removed_settings as $setting) {
      $config->clear($setting);
    }

    // Save the changes.
    $config->save(TRUE);
  }
}

/**
 * Remove ckeditor4 usage from configuration.
 */
function patternkit_update_9006(): ?string {
  $config_key = 'patternkit.settings';
  $wysiwyg_setting = 'patternkit_json_editor_wysiwyg';
  $config = \Drupal::configFactory()->getEditable($config_key);

  if ($config && $config->get($wysiwyg_setting) === 'ckeditor') {
    // Remove ckeditor and toolbar configuration.
    $config->set($wysiwyg_setting, '');
    $config->set('patternkit_json_editor_ckeditor_toolbar', '');

    // Save the changes.
    $config->save(TRUE);

    return t('Patternkit configuration using CKEditor 4 was removed. These settings will need to be reconfigured.');
  }

  return NULL;
}

/**
 * Add token clear option to configuration.
 */
function patternkit_update_9007(): ?string {
  $config = \Drupal::configFactory()->getEditable('patternkit.settings');

  // Only set the new setting if it doesn't exist yet.
  if ($config && $config->get('patternkit_json_editor_token_clear') === NULL) {
    $config->set('patternkit_json_editor_token_clear', FALSE);
    $config->save(TRUE);

    return t('Patternkit configuration updated with default value for token clear option.');
  }

  return NULL;
}

/**
 * Replace theme selections that were removed.
 */
function patternkit_update_10001(): void {
  $config_key = 'patternkit.settings';
  $theme_key = 'patternkit_json_editor_theme';
  $default_theme = 'cygnet';

  $config = \Drupal::configFactory()->getEditable($config_key);

  if ($config) {
    $selected_theme = $config->get($theme_key);

    if (!isset(PatternLibraryJSONForm::THEMES[$selected_theme])) {
      $config->set($theme_key, $default_theme);
      $config->save(TRUE);
    }
  }
}

/**
 * Clear Patternkit icon selections that were removed.
 */
function patternkit_update_10002(): void {
  $config_key = 'patternkit.settings';
  $setting = 'patternkit_json_editor_icons';

  $config = \Drupal::configFactory()->getEditable($config_key);

  if ($config) {
    $selected = $config->get($setting);

    if (!isset(PatternLibraryJSONForm::ICONS[$selected])) {
      $config->clear($setting);
      $config->save(TRUE);
    }
  }
}

/**
 * Reset configuration for removed WYSIWYG editors.
 */
function patternkit_update_10003(): ?string {
  $config_key = 'patternkit.settings';
  $wysiwyg_setting = 'patternkit_json_editor_wysiwyg';
  $config = \Drupal::configFactory()->getEditable($config_key);

  if ($config && !isset(PatternLibraryJSONForm::EDITORS[$config->get($wysiwyg_setting)])) {
    // Remove ckeditor and toolbar configuration.
    $config->clear($wysiwyg_setting);
    $config->clear('patternkit_json_editor_ckeditor_toolbar');

    // Save the changes.
    $config->save(TRUE);

    return t('Patternkit configuration using removed editors was found. These settings will need to be reconfigured.');
  }

  return NULL;
}

/**
 * Remove config for deprecated JSON Editor form JS and CSS attachment fields.
 */
function patternkit_update_10004(): string {
  $config_key = 'patternkit.settings';
  $config = \Drupal::configFactory()->getEditable($config_key);

  $message = '';
  if ($existing_css_value = $config->get('patternkit_json_editor_css')) {
    $message .= t("Values for removed JSON Editor CSS additions were deleted: %settings\n", [
      '%settings' => $existing_css_value,
    ]);
  }
  if ($existing_js_value = $config->get('patternkit_json_editor_js')) {
    $message .= t("Values for removed JSON Editor JS additions were deleted: %settings\n", [
      '%settings' => $existing_js_value,
    ]);
  }

  $config->clear('patternkit_json_editor_css');
  $config->clear('patternkit_json_editor_js');

  $config->save(TRUE);

  return $message;
}

/**
 * Migrate value for removed icons libraries.
 */
function patternkit_update_10005(): string {
  $config_key = 'patternkit.settings';
  $config = \Drupal::configFactory()->getEditable($config_key);
  $message = '';

  $icons_set_current = $config->get('patternkit_json_editor_icons');
  if (empty($icons_set_current) || !isset(PatternLibraryJSONForm::ICONS[$icons_set_current])) {
    $config->set('patternkit_json_editor_icons', '_none');
    $config->save();

    $message .= t('Icons set @current was changed to _none because support for that icons set has been removed.', [
      '@current' => $icons_set_current,
    ]);
  }

  return $message;
}

/**
 * Deprecated: Update config with new entity_cache_tag_invalidation setting.
 */
function patternkit_update_10305(): string {
  return t('Replaced by patternkit_update_10306().');
}

/**
 * Update config with new entity_cache_tag_invalidation setting.
 */
function patternkit_update_10306(): string {
  // Replaces patternkit_update_10305().
  $config_key = 'patternkit.settings';
  $config = \Drupal::configFactory()->getEditable($config_key);
  $message = '';

  $current = $config->get('entity_cache_tag_invalidation');
  if ($current === NULL) {
    $config->set('entity_cache_tag_invalidation', FALSE);
    $config->save();
    $message = t('Set new Patternkit entity cache tag invalidation setting to FALSE.');
  }

  return $message;
}

/**
 * Update patternkit block records to correctly reference pattern ids.
 */
function patternkit_update_10307(): string {
  $storage = \Drupal::entityTypeManager()->getStorage('patternkit_block');
  $query = $storage->getQuery();
  $matches = $query->condition('pattern_id', '@%', 'NOT LIKE')
    ->accessCheck()
    ->execute();
  /** @var \Drupal\patternkit\Entity\PatternkitBlock[] $entities */
  $entities = $storage->loadMultiple($matches);

  $updated = 0;
  foreach ($entities as $block) {
    $derivative_id = $block->get('pattern_id')->value;
    $asset_id = DerivativePatternkitBlock::derivativeToAssetId($derivative_id);
    $block->set('pattern_id', $asset_id, FALSE);
    $block->save();
    $updated++;

    \Drupal::logger('patternkit')->notice('Updated Patternkit block ID @id to correct pattern asset ID from "@old" to "@new".',
      [
        '@id' => $block->id(),
        '@old' => $derivative_id,
        '@new' => $asset_id,
      ]);
  }

  if ($updated > 0) {
    return \Drupal::translation()
      ->formatPlural($updated, 'Fixed asset IDs for 1 block.', 'Fixed asset IDs for @count blocks.');
  }
  else {
    return t('No invalid asset IDs were found.');
  }
}

/**
 * Capture unsaved changes in Patternkit blocks.
 */
function patternkit_update_10308(): string {
  // Identify all patternkit blocks with serialized changes.
  $block_storage = \Drupal::entityTypeManager()->getStorage('block');
  $query = $block_storage->getQuery();
  $matches = $query->condition('settings.provider', 'patternkit')
    ->condition('settings.block_serialized', operator: 'IS NOT NULL')
    ->accessCheck(FALSE)
    ->execute();
  $entities = $block_storage->loadMultiple($matches);

  $message = \Drupal::translation()
    ->formatPlural(count($entities),
      'Identified 1 Patternkit Block with unsaved changes.',
      'Identified @count Patternkit blocks with unsaved changes.'
    );
  \Drupal::logger('patternkit')->notice($message);

  // Save serialized content changes.
  $updated = 0;
  foreach ($entities as $block) {
    $plugin = $block->getPlugin();

    if (!($plugin instanceof BlockPatternkitBlock)) {
      \Drupal::logger('patternkit')->warning(
        'Skipping config block "@id" (plugin "@block_id"): plugin did not resolve to a PatternkitBlock instance. Pending serialized edits for this block were not applied.',
        [
          '@id' => $block->id(),
          '@block_id' => $block->getPluginId(),
        ]
      );
      continue;
    }

    $plugin->cachePatternEntity();
    $plugin->saveBlockContent(TRUE);
    $post_save_configuration = $plugin->getConfiguration();
    $block->set('settings', $post_save_configuration);
    $block->save();
    $updated++;
  }

  if ($updated > 0) {
    return \Drupal::translation()
      ->formatPlural($updated, 'Saved updated configuration for 1 block.', 'Saved updated configuration for @count blocks.');
  }
  else {
    return t('No invalid blocks were found.');
  }
}

/**
 * No-op: retain reusable field storage until 9.2.0 removal.
 *
 * Supersedes the prior 9.1.x update that dropped the reusable column before
 * the 9.1.3 migration window. Sites that already ran the column drop keep that
 * state; this hook is a no-op for upgrades that had not yet run it.
 *
 * Sites that already ran the pre-release removal are handled by
 * patternkit_update_10310(), which restores the column. Because update hooks
 * run exactly once (tracked by system.schema), a modified 10309 would never
 * re-execute for those sites; a new hook number is required.
 *
 * @see https://www.drupal.org/project/patternkit/issues/3587714
 * @see https://www.drupal.org/project/patternkit/issues/3587730
 */
function patternkit_update_10309(): string {
  return t('No schema change: Patternkit reusable block field storage is retained for the 9.1.x migration window; removal is scheduled for 9.2.0.');
}

/**
 * Restore reusable field storage dropped by a pre-release removal hook.
 *
 * A pre-release build of 9.1.x shipped patternkit_update_10309() as a
 * column-drop. Sites that ran that hook have no reusable column, which causes
 * hook_requirements() to throw a DB exception on the status report page.
 * Because 10309 already executed on those sites it is skipped on upgrade;
 * this hook restores the field storage so the 9.1.x migration window is
 * available to all sites.
 *
 * Sites where the column is already present follow the no-op path.
 *
 * @see https://www.drupal.org/project/patternkit/issues/3587714
 * @see https://www.drupal.org/project/patternkit/issues/3587730
 */
function patternkit_update_10310(): string {
  $edm = \Drupal::entityDefinitionUpdateManager();
  if ($edm->getFieldStorageDefinition('reusable', 'patternkit_block')) {
    return t('No schema change: reusable field storage is already present.');
  }
  $field_definitions = \Drupal::service('entity_field.manager')
    ->getBaseFieldDefinitions('patternkit_block');
  $edm->installFieldStorageDefinition(
    'reusable',
    'patternkit_block',
    'patternkit',
    $field_definitions['reusable']
  );
  return t('Restored reusable field storage for the 9.1.x migration window.');
}