@webship.co/workspace 1.0.0-beta1 → 1.0.0-beta2

package/core/scripts/functions/fun-build-distribution.sh

@@ -0,0 +1,226 @@
+#!/usr/bin/env bash
+
+# composer install, once more if it fails: the first install in a fresh project can fail on a git cache hiccup
+# ("<commit> is gone") and pass straight away on the second try. A real dependency problem fails both times.
+function composer_install_retry() {
+  ddev composer install --no-interaction && return 0 ;
+  echo "composer install failed once, trying it again before giving up." ;
+  ddev composer install --no-interaction ;
+}
+
+function build_distribution() {
+  # Include distribution functions.
+  source ${WORKSPACE_SCRIPTS}/functions/fun-distribution-${distribution_name}.sh || exit 1 ;
+
+  base_url="https://${PROJECT_NAME}.ddev.site";
+
+  # Change directory to the workspace for this full operation.
+  cd ${WORKSPACE_ROOT}/${doc_name};
+
+  if [ ! "${SKIP_DROP_DATABASE}" == 'yes' ] ; then
+    drop_database;
+  fi
+
+  if [ -d "${PROJECT_NAME}" ]; then
+    rm -rf ${PROJECT_NAME}
+  fi
+
+  # Create the project folder and bring up its DDEV environment first, so
+  # composer/drush run inside the project's own containers from here on.
+  mkdir -p ${PROJECT_NAME} ;
+  cd ${WORKSPACE_ROOT}/${doc_name}/${PROJECT_NAME} ;
+
+  # Which PHP the project gets, from the most specific answer available:
+  #
+  #   1. --php-version, if whoever ran this asked for one;
+  #   2. site_php_version, if the BUILDER declares one its core requires — Drupal 12 does, its
+  #      composer.json says `php: >=8.5.0` and DDEV's default is 8.4, so without it the build gets as
+  #      far as composer and stops on a platform requirement, which reads as the builder being broken
+  #      rather than as a version being needed;
+  #   3. nothing, and DDEV picks its own default exactly as before.
+  #
+  # The flag wins over the builder's declaration on purpose: a builder says what its core NEEDS, and
+  # somebody passing --php-version is saying what they want to build on — testing an older PHP against
+  # a core that allows it is the whole reason the flag exists. A version the core cannot take fails in
+  # composer with a platform requirement that names it, which is a better answer than silently
+  # ignoring what was asked for.
+  php_version="${PHP_VERSION:-${site_php_version:-}}" ;
+  ddev config --project-type=drupal --docroot=${distribution_webroot} --project-name=${PROJECT_NAME} \
+    ${php_version:+--php-version=${php_version}} --nodejs-version=$(ddev_nodejs_version) --auto ;
+  ddev_telemetry_off ;
+  ddev_up start ;
+
+  # Capture the db type actually running before composer create-project can change it,
+  # so the re-align below restores it instead of a stale hardcoded version.
+  provisioned_db_type=$(grep -A2 '^database:' .ddev/config.yaml | grep 'version:' | awk '{print $2}' | tr -d '"') ;
+
+  # --dev builds the development branch instead of the pinned release. Each
+  # builder that supports it declares site_version_dev next to site_version;
+  # asking for --dev on one that does not is an error, not a silent fallback.
+  if [ "${DEV}" == 'yes' ] ; then
+    if [ -z "${site_version_dev}" ] ; then
+      echo "--dev is not supported by this builder (no development branch declared)." ;
+      cd ${WORKSPACE_ROOT}/${doc_name};
+      return 1 ;
+    fi
+    site_version="${site_version_dev}" ;
+    # A development branch's dependencies are development branches too.
+    dev_stability="--stability dev" ;
+  elif [ -n "${site_version_stability}" ] ; then
+    # A major that has not reached a stable release yet. Composer's default minimum is
+    # `stable`, so a caret constraint that today matches only an alpha resolves to
+    # NOTHING and the build stops with "could not find a version in a stable enough
+    # version" — which is how a latest-per-major builder looks broken on the day the
+    # major it tracks opens. A declared floor says how far down this builder is willing
+    # to go, and it needs no edit later: composer still prefers the highest match, so
+    # the first stable release wins over every pre-release of it on its own.
+    dev_stability="--stability ${site_version_stability}" ;
+  fi
+
+  # A failed create-project (e.g. an upstream patch no longer applying) must stop the
+  # build here — every step after this assumes a real vendor/autoload.php exists.
+  #
+  # A release line may need two things before its first install, or composer cannot resolve it at all:
+  #   site_composer_requires  root requirements, e.g. an alias. a Drupal 10 line may ask for a package
+  #                           that moved to Drupal 11, so the line aliases the last Drupal 10 release.
+  #   site_patches_ignore     "<package> <patch-url>" pairs that webship/patches declares and the release
+  #                           already contains, so applying the patch fails (patches-ignore, added to composer.json).
+  # Both are declared by the builder as bash arrays. A builder that declares neither installs in one step as before.
+  site_requires=("${site_composer_requires[@]}") ;
+  site_ignores=("${site_patches_ignore[@]}") ;
+  if [ -n "${site_requires[0]:-}${site_ignores[0]:-}" ] ; then
+    if ! ddev composer create-project ${distribution_project_template}:${site_version} . --no-interaction --no-install --no-scripts ${dev_stability:-} ; then
+      echo "composer create-project failed for ${distribution_project_template}:${site_version} — aborting, not installing." ;
+      cd ${WORKSPACE_ROOT}/${doc_name};
+      return 1 ;
+    fi
+    if [ -n "${site_requires[0]:-}" ] ; then
+      ddev composer require "${site_requires[@]}" --no-update --no-interaction || { cd ${WORKSPACE_ROOT}/${doc_name}; return 1 ; } ;
+    fi
+    if [ -n "${site_ignores[0]:-}" ] ; then
+      patches_ignore_json=$(python3 -c 'import sys, json; d = {}; [d.setdefault("webship/patches", {}).setdefault(a.split(" ", 1)[0], []).append(a.split(" ", 1)[1]) for a in sys.argv[1:]]; print(json.dumps(d))' "${site_ignores[@]}") ;
+      ddev composer config --json extra.patches-ignore "${patches_ignore_json}" || { cd ${WORKSPACE_ROOT}/${doc_name}; return 1 ; } ;
+    fi
+    if ! composer_install_retry || ! ddev composer run-script post-create-project-cmd ; then
+      echo "composer could not install ${distribution_project_template}:${site_version} — aborting, not installing." ;
+      cd ${WORKSPACE_ROOT}/${doc_name};
+      return 1 ;
+    fi
+  elif ! ddev composer create-project ${distribution_project_template}:${site_version} . --no-interaction ${dev_stability:-} ; then
+    # When the project reached the install step, composer.json is already in place: install once more.
+    if [ -f composer.json ] && composer_install_retry && ddev composer run-script post-create-project-cmd ; then
+      echo "composer create-project needed a second install, which worked." ;
+    else
+      echo "composer create-project failed for ${distribution_project_template}:${site_version} — aborting, not installing." ;
+      cd ${WORKSPACE_ROOT}/${doc_name};
+      return 1 ;
+    fi
+  fi
+
+  # A failed create-project (an upstream patch that no longer applies, a yanked tag) has to stop
+  # the build here. Every step below assumes a real vendor/autoload.php, so carrying on used to
+  # mean "installing" nothing and then announcing success.
+  if ! ddev composer create-project ${distribution_project_template}:${site_version} . --no-interaction ; then
+    echo "composer create-project failed for ${distribution_project_template}:${site_version} — aborting, nothing was installed." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  # Some project templates ship their own .ddev config that
+  # changes the docroot/database/webimage packages after our initial ddev
+  # config. Re-align: keep the database type we already provisioned, drop
+  # optional apt extras (avoids third-party repo key failures), keep our Node.js, and restart
+  # so the webserver serves the template's real docroot.
+  ddev config --database=mariadb:${provisioned_db_type} --webimage-extra-packages="" --nodejs-version=$(ddev_nodejs_version) ;
+  ddev_telemetry_off ;
+  ddev_up restart ;
+
+  # The template may define a different webroot than the distribution config
+  # assumed — trust the project's own .ddev config from here on.
+  actual_docroot=$(grep '^docroot:' .ddev/config.yaml | awk '{print $2}') ;
+  if [ -n "${actual_docroot}" ] && [ "${actual_docroot}" != "${distribution_webroot}" ]; then
+    echo "Template webroot is '${actual_docroot}' (distribution config said '${distribution_webroot}') — using the template's." ;
+    distribution_webroot=${actual_docroot} ;
+  fi
+
+  # Change the minimum stablility to dev for development
+  ddev composer config minimum-stability dev ;
+
+  # Require all custom required packages.
+  echo "Require all custom required packages.";
+  # argparse.sh emits an nargs='+' option as a bash ARRAY, so a plain ${REQUIRE} is only its
+  # FIRST element: `--require drupal/token drupal/ctools` used to install token and drop ctools
+  # without a word. [0] still reads the sentinel when the default scalar is in place.
+  if [ "${REQUIRE[0]}" == '_none_' ] ; then
+    echo "No extra composer required." ;
+  else
+    ddev composer require ${REQUIRE[*]} ;
+  fi
+
+  ## Add default settings file before starting the install.
+  if [ ! "$SKIP_SET_DEFULT_SETTINGS" == 'yes' ] ; then
+    set_default_settings ;
+  fi
+
+  ## Install the site.
+  if [ "$INSTALL" == 'yes' ] ; then
+    echo "Install the site";
+
+    # Add Drush if it was not in the system.
+    add_drush ;
+
+    # Change directory to the webroot.
+    cd ${WORKSPACE_ROOT}/${doc_name}/${PROJECT_NAME}/${distribution_webroot};
+
+    # Install distribution with Drush. A failed install stops the build: every step after it assumes an
+    # installed site, and carrying on printed "has been installed" over a half-installed one.
+    if ! install_${distribution_name}_with_drush ; then
+      echo "The install of ${doc_name} ${PROJECT_NAME} failed — drush site:install did not finish, so the site is not usable." ;
+      echo "The project is kept for inspection: ${base_url} (ddev logs, ddev drush status)." ;
+      cd ${WORKSPACE_ROOT}/${doc_name};
+      return 1 ;
+    fi
+    # Enable extra components;
+    enable_${distribution_name}_extra_components ;
+    # Set Aggrigation off and error level all
+    drush_set_debug_on;
+    # Cache Rebuilding ...
+    drush_cr;
+
+    # A step above can leave the site installed but broken (a module that fails half way). Say so here,
+    # instead of announcing an installed site that answers with a 500.
+    if ! ddev drush status --field=bootstrap 2>/dev/null | grep -q Successful ; then
+      echo "${doc_name} ${PROJECT_NAME} was installed, but Drupal does not bootstrap: a step above failed half way." ;
+      echo "Read the 'Failed to run' lines above, or run: ddev drush status ; ddev logs." ;
+      cd ${WORKSPACE_ROOT}/${doc_name};
+      return 1 ;
+    fi
+
+    if [ "${ENABLE[0]}" == '_none_' ] ; then
+      echo "No extra selected modules to enable." ;
+    else
+      ddev drush pm:enable ${ENABLE[*]} --yes;
+    fi
+
+    ## Add default set of users.
+    if [ "$ADD_USERS" == 'yes' ] ; then
+    add_users ;
+    fi
+
+    # Send a notification.
+    echo "${doc_name} ${PROJECT_NAME} has been installed!!!!";
+    echo "Go to ${base_url}";
+
+  else
+    echo "${doc_name} ${PROJECT_NAME} is ready to install!!!!";
+    echo "Go to ${base_url}";
+  fi
+
+  # --launch opens the site in the browser: the installed site, or the browser
+  # installer when --install was not asked for.
+  if [ "${LAUNCH}" == 'yes' ] ; then
+    ddev launch ;
+  fi
+
+  cd ${WORKSPACE_ROOT}/${doc_name};
+}

package/core/scripts/functions/fun-build-site-template.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+
+# Build a Drupal CMS site from a site template, and install it.
+#
+# A site template is a `Site` recipe (https://new.drupal.org/browse/site-templates).
+# The installer normally asks which one to use; `drush site:install` answers that
+# step non-interactively through the installer form:
+#
+#   installer_site_template_form.add_ons=<recipe directory name>
+#
+# The recipe directory name is the package name without the `drupal/` vendor
+# prefix, which is where composer puts a `drupal-recipe` package. The question
+# comes from the `drupal_cms_installer` profile; any distribution that asks it
+# with the same form id and the same `add_ons` element works too — set
+# `installer_profile` to pick which one.
+#
+# The calling cmd-*.sh sets: site_template_name, site_template_package and,
+# optionally, site_template_title and installer_profile.
+function build_site_template() {
+
+  # Which install profile asks the site-template question.
+  installer_profile="${installer_profile:-drupal_cms_installer}";
+
+  # No flags: the latest release of the template, and the PHP version DDEV chooses.
+  SITE_TEMPLATE_VERSION="";
+  PHP_VERSION="${PHP_VERSION:-8.3}";
+
+  base_url="https://${PROJECT_NAME}.ddev.site";
+  hub_url="https://${PROJECT_NAME}.${doc_name}.workspace.ddev.site";
+
+  # Change directory to the workspace for this full operation.
+  cd ${WORKSPACE_ROOT}/${doc_name};
+
+  drop_database;
+
+  if [ -d "${PROJECT_NAME}" ]; then
+    rm -rf ${PROJECT_NAME}
+  fi
+
+  mkdir -p ${PROJECT_NAME} ;
+  cd ${WORKSPACE_ROOT}/${doc_name}/${PROJECT_NAME} ;
+
+  ddev config --project-type=drupal11 --docroot=${distribution_webroot} --php-version=${PHP_VERSION} --nodejs-version=$(ddev_nodejs_version) --project-name=${PROJECT_NAME} --auto ;
+  ddev start ;
+
+  # Capture the database version DDEV actually provisioned, before composer create-project can
+  # bring its own .ddev config in and change it.
+  provisioned_db_type=$(grep -A2 '^database:' .ddev/config.yaml | grep 'version:' | awk '{print $2}' | tr -d '"') ;
+
+  if ! ddev composer create-project ${distribution_project_template} . --no-interaction ; then
+    echo "composer create-project failed for ${distribution_project_template} — aborting, nothing was installed." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  # Keep the database we provisioned and drop optional apt extras, in case the
+  # project template shipped its own .ddev config.
+  ddev config --database=mariadb:${provisioned_db_type} --webimage-extra-packages="" --php-version=${PHP_VERSION} --nodejs-version=$(ddev_nodejs_version) ;
+  ddev restart ;
+
+  # Add the site template itself.
+  if [ -n "${SITE_TEMPLATE_VERSION}" ]; then
+    ddev composer require "${site_template_package}:${SITE_TEMPLATE_VERSION}" --no-interaction;
+  else
+    ddev composer require "${site_template_package}" --no-interaction;
+  fi
+
+  echo "Install ${distribution_title:-Drupal CMS} with the ${site_template_title:-${site_template_name}} site template.";
+  # Stop here when the install fails: a site template that throws part way
+  # through leaves a half-installed site (config applied, default content
+  # never imported), and running the user/debug steps on top of that hides
+  # which step actually broke.
+  if ! ddev drush site:install ${installer_profile} --yes \
+    installer_site_template_form.add_ons=${site_template_name} \
+    --site-name="${site_template_title:-${site_template_name}}" \
+    --account-name="${account_name}" --account-pass="${account_pass}" --account-mail="${account_mail}" \
+    --locale="en" ; then
+    echo "" ;
+    echo "The ${site_template_title:-${site_template_name}} install failed — the site is half-installed." ;
+    echo "Read the error above: a site template that pins a stale Canvas component_version," ;
+    echo "or ships config another module already provides, fails at the recipe step." ;
+    echo "To take the same steps by hand, use ${base_url}/core/install.php and pick the template there." ;
+    cd ${WORKSPACE_ROOT}/${doc_name} ;
+    return 1 ;
+  fi
+
+  # Set aggregation off and the error level to all, then rebuild caches.
+  drush_set_debug_on;
+  drush_cr;
+
+  ## Add the default set of users.
+  if [ "${ADD_USERS}" == 'yes' ] ; then
+  add_users ;
+  fi
+
+  echo "";
+  echo "*---------------------------------------------------------------------*";
+  echo "  ${site_template_title:-${site_template_name}} is ready:";
+  echo "    ${hub_url}";
+  echo "    ${base_url}";
+  echo "*---------------------------------------------------------------------*";
+
+  cd ${WORKSPACE_ROOT}/${doc_name};
+}

package/core/scripts/functions/fun-build-webships.sh

@@ -0,0 +1,161 @@
+#!/usr/bin/env bash
+
+# Build the Webships API stack (Drupal 11.4, PHP 8.4):
+#
+#   build_webships_project        drupal/webships_project, installed by the Webships
+#                                 installer (`drush site:install webships`) with the
+#                                 chosen API site template.
+#   build_webships_site_template  one API site-template recipe on
+#                                 drupal/recommended-project 11.4.x, installed with
+#                                 `drush site:install <recipe directory>`.
+#
+# The calling cmd-*.sh sets distribution_* and site_version, and for a recipe build
+# site_template_name, site_template_title and site_template_package.
+#
+# Two things differ from the website stack and are easy to get wrong:
+#
+#  1. The installer profile is on 3.0.x while the project template is on 1.0.x. The
+#     version a builder sets is the PROJECT TEMPLATE's, because that is what
+#     `composer create-project` receives. The profile comes in through the template's
+#     own `webship/webships: ^3` constraint.
+#  2. The API documentation asset library only installs from a root project package,
+#     so it is the project template's job. A recipe build has no Swagger assets, and
+#     that is expected rather than a fault.
+
+webships_php_version="8.4";
+webships_core_version="11.4.x-dev";
+
+# A clean DDEV project for PROJECT_NAME in this workspace, with the codebase of
+# `$1` (a composer project template with its version) in it.
+function webships_create_project() {
+  base_url="https://${PROJECT_NAME}.ddev.site";
+
+  cd ${WORKSPACE_ROOT}/${doc_name};
+  drop_database;
+  if [ -d "${PROJECT_NAME}" ]; then
+    rm -rf ${PROJECT_NAME}
+  fi
+  mkdir -p ${PROJECT_NAME} ;
+  cd ${WORKSPACE_ROOT}/${doc_name}/${PROJECT_NAME} ;
+
+  ddev config --project-type=drupal --docroot=${distribution_webroot} --php-version=${PHP_VERSION:-${webships_php_version}} --nodejs-version=$(ddev_nodejs_version) --project-name=${PROJECT_NAME} --auto ;
+  ddev start -y ;
+
+  if ! ddev composer create-project "$1" . --no-interaction ; then
+    echo "composer create-project failed for $1 — aborting, nothing was installed." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  # The API packages ship stable releases and development releases side by side;
+  # a build of the development line needs dev to be acceptable.
+  ddev composer config minimum-stability dev ;
+  ddev composer config prefer-stable true ;
+
+  # Keep the API site templates as recipes, the way the project template does:
+  # the installer finds them in recipes/ without Composer unpacking them.
+  ddev composer config --json --merge extra.drupal-recipe-unpack.ignore '["drupal/webships_starter", "drupal/webapi_starter"]' ;
+}
+
+# The shared steps after a successful install.
+function webships_after_install() {
+  drush_set_debug_on;
+  drush_cr;
+
+  if [ "${ADD_USERS}" == 'yes' ] ; then
+    add_users ;
+  fi
+
+  echo "";
+  echo "*---------------------------------------------------------------------*";
+  echo "  ${PROJECT_NAME} is ready: ${base_url}";
+  echo "  The API is served from ${base_url}/api";
+  echo "  The API documentation is at ${base_url}/api-docs";
+  echo "*---------------------------------------------------------------------*";
+
+  cd ${WORKSPACE_ROOT}/${doc_name};
+}
+
+# Report what the built site actually serves, rather than assuming the recipe applied.
+function webships_report_api_state() {
+  echo "";
+  echo "JSON:API read-only setting:";
+  ddev drush config:get jsonapi.settings read_only 2>/dev/null || echo "  (jsonapi.settings not readable)" ;
+  echo "Themes:";
+  ddev drush config:get system.theme 2>/dev/null || echo "  (system.theme not readable)" ;
+}
+
+# drupal/webships_project installed by the Webships installer with --template.
+function build_webships_project() {
+  local template="${TEMPLATE:-webships_starter}" ;
+
+  webships_create_project "${distribution_project_template}:${site_version}" || return 1 ;
+
+  # Add whatever the published project template does not require yet, so a build
+  # of an older tag still gets both API site templates.
+  local require_block missing=() ;
+  require_block=$(sed -n '/"require": {/,/}/p' composer.json) ;
+  for package in "drupal/webships_starter:^1" "drupal/webapi_starter:^1" ; do
+    if ! echo "${require_block}" | grep -q "\"${package%%:*}\"" ; then
+      echo "${distribution_project_template} does not require ${package%%:*} yet — adding it." ;
+      missing+=("${package}") ;
+    fi
+  done
+
+  local composer_ok=1 ;
+  if [ ${#missing[@]} -gt 0 ] ; then
+    ddev composer require --no-update --no-interaction "${missing[@]}" || composer_ok=0 ;
+    if [ ${composer_ok} -eq 1 ] ; then
+      ddev composer update -W --no-interaction || composer_ok=0 ;
+    fi
+  fi
+  if [ ${composer_ok} -eq 0 ] ; then
+    echo "composer failed — aborting before the install." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  set_default_settings ;
+
+  echo "Install ${distribution_title} with the Webships installer and the ${template} site template.";
+  if ! ddev drush site:install webships --yes \
+    installer_site_template_form.add_ons=${template} \
+    --site-name="${distribution_title}" \
+    --account-name="${account_name}" --account-pass="${account_pass}" --account-mail="${account_mail}" \
+    --locale="en" ; then
+    echo "" ;
+    echo "The ${template} install failed — read the error above. The codebase is kept: ${base_url}/core/install.php" ;
+    cd ${WORKSPACE_ROOT}/${doc_name} ;
+    return 1 ;
+  fi
+
+  webships_report_api_state ;
+  webships_after_install ;
+}
+
+# One API site-template recipe on a plain Drupal 11.4.x recommended project.
+function build_webships_site_template() {
+  webships_create_project "drupal/recommended-project:${webships_core_version}" || return 1 ;
+
+  if ! ddev composer require -W --no-interaction "drush/drush:^13" "${site_template_package}:${site_version}" ; then
+    echo "composer require ${site_template_package}:${site_version} failed — aborting before the install." ;
+    cd ${WORKSPACE_ROOT}/${doc_name};
+    return 1 ;
+  fi
+
+  set_default_settings ;
+
+  echo "Install Drupal ${webships_core_version} with the ${site_template_title} recipe.";
+  if ! ddev drush site:install /var/www/html/recipes/${site_template_name} --yes \
+    --site-name="${site_template_title}" \
+    --account-name="${account_name}" --account-pass="${account_pass}" --account-mail="${account_mail}" \
+    --locale="en" ; then
+    echo "" ;
+    echo "The ${site_template_title} install failed — read the error above." ;
+    cd ${WORKSPACE_ROOT}/${doc_name} ;
+    return 1 ;
+  fi
+
+  webships_report_api_state ;
+  webships_after_install ;
+}