Issue #3291663 by alexpott, daniel.bosen: The composer plugin cannot apply recipes

### Drupal recipe

[Drupal recipes](recipe.md) allow the automation of Drupal module install and

configuration via the user interface and via the Drupal recipe composer plugin.

configuration via the user interface and via the Drupal recipe runner.

# What is a Drupal recipe?

Drupal recipes allow the automation of Drupal module install and configuration

via the user interface and via the Drupal recipe composer plugin.

via the user interface and via the Drupal recipe runner.

A Drupal recipe is a tool for Site Builders and Developers to add functionality

to a Drupal site. It is like a recipe that provides a series of steps to add

    * screenshot.jpg/png/gif (optional)

    * /config directory (optional)

    * /content directory (optional)

* Recipes can be discovered in:

  * /core/recipes - this is where core supplied recipes will be.

  * /recipes - this is where custom and contrib recipes will be.

* A composer plugin detects composer project types of `drupal-recipe`. When

  requiring a recipe it

  will [unpack](http://fabien.potencier.org/symfony4-unpack-the-packs.html) the

  dependencies into the root composer.json.

  installing a recipe it will:

  * Copy the recipe to DRUPAL_ROOT/recipes. If there is an existing recipe this

    will cause an error.

  * [unpack](http://fabien.potencier.org/symfony4-unpack-the-packs.html)

    the dependencies into the root composer.json.

  * This has the following effects:

    * Using composer means that dependency resolution and compatibilities are

      composer's responsibility.

    * [Unpacking](http://fabien.potencier.org/symfony4-unpack-the-packs.html)

      the recipe's composer.json into the root composer.json ensures that

      recipes don't influence the autoloader and do not have to be removed.

      recipes can be removed without removing their dependencies.

    * This is inspired by [Symfony Flex](https://github.com/symfony/flex). We

      are still determining how much Symfony code & practice we can leverage.

* Prior to installing the modules, the composer plugin checks that they exist

  and their requirements are met.

* Prior to installing the modules, the recipe runner checks that they exist and

  their requirements are met.

    * Proposal: use Package Manager's API from the automated update initiative.

* The composer plugin leverages the module install to install the list of

* The recipe runner leverages the module install to install the list of

  modules from the Drupal recipe

    * During install we only install the simple configuration the module

      provides. We do not create any configuration entities or optional

      configuration by default. Only config entities explicitly declared in

      the "config:" section of the recipe file are installed.

* Prior to creating or modifying configuration, the composer plugin checks that

* Prior to creating or modifying configuration, the recipe runner checks that

  the configuration is valid (its dependencies can be met).

    * This needs to happen after module install because config validation can

      only occur when modules that provide the schema and plugins are installed.

* Configuration in the recipe's /config directory is always installed by the

  composer plugin.

  recipe runner.

    * Should we support the ability to choose specific config? For example, it

      might be nice to support tours by allowing a Drupal recipe to ship with

      tours and then if the tour module is not installed by the Drupal recipe

  It is also able to pick out specific configurations from the modules it

  requires. It does not need to provide all the configuration in its config

  folder.

* The composer plugin can create content provided by the Drupal recipe. The

  composer plugin asks if you want to also install the provided content.

* The recipe runner can create content provided by the Drupal recipe. The

  recipe runner asks if you want to also install the provided content.

    * Prior

      art: [Default content](https://www.drupal.org/project/default_content)

      module, [Open Social custom code](https://github.com/goalgorilla/open_social/tree/main/modules/custom/social_demo)

Main aim: to create the ability to apply an arbitrary recipe to a Drupal install

* [#2094481](https://www.drupal.org/project/drupal/issues/2094481) Default content in core

* Create/extend composer plugin to process drupal-recipe composer.json files and

  unpack their dependencies into the root composer.json

* Create/extend composer plugin to process drupal-recipe recipe.yml files to

* Create recipe runner to process drupal-recipe recipe.yml files to

  install listed drupal extensions without their configuration entities

* Extend composer plugin to create configuration provided in the recipe's

* Extend recipe runner to create configuration provided in the recipe's

  /config folder

* Extend composer plugin to allow recipe.yml to select configuration from

* Extend recipe runner to allow recipe.yml to select configuration from

  installed modules

* Add the ability to define configuration actions

* Extend composer plugin to process configuration actions listed in the

* Extend recipe runner to process configuration actions listed in the

  recipe.yml

* Extend composer plugin to create content provided in the recipe's /content

* Extend recipe runner to create content provided in the recipe's /content

  folder

## Phase 2

Main aim: to create a user interface for applying recipes

Main aims are to create a user interface for applying recipes and manage recipes

via composer.

TBD, includes:

* Hosting recipes on Drupal.org

* Discovery by some tool

* Drupal recipe testing

* Create composer plugin react when a drupal recipe is installed to unpack the

  recipe's dependencies and copy it to PROJECT_ROOT/recipes

## Phase 3