@adobe/aio-cli-plugin-app 9.2.0 → 10.0.0

package/src/TemplatesCommand.js

@@ -0,0 +1,256 @@
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const AddCommand = require('./AddCommand')
+const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:TemplatesCommand', { provider: 'debug' })
+const inquirerTableCheckbox = require('@adobe/inquirer-table-checkbox')
+const inquirer = require('inquirer')
+const TemplateRegistryAPI = require('@adobe/aio-lib-templates')
+const hyperlinker = require('hyperlinker')
+const ora = require('ora')
+const terminalSize = require('term-size')
+
+class TemplatesCommand extends AddCommand {
+  /**
+   * Gets a list of templates from the Template Registry API using the criteria provided.
+   *
+   * @param {object} searchCriteria the Template Registry API search criteria
+   * @param {object} orderByCriteria the Template Registry API orderBy criteria
+   * @param {object} [templateRegistryConfig={}] the optional Template Registry API config
+   * @returns {Array<object>} list of templates
+   */
+  async getTemplates (searchCriteria, orderByCriteria, templateRegistryConfig = {}) {
+    const templateRegistryClient = TemplateRegistryAPI.init(templateRegistryConfig)
+    const templateList = []
+
+    const templatesIterator = templateRegistryClient.getTemplates(searchCriteria, orderByCriteria)
+
+    for await (const templates of templatesIterator) {
+      for (const template of templates) {
+        templateList.push(template)
+      }
+    }
+    aioLogger.debug('template list', JSON.stringify(templateList, null, 2))
+
+    return templateList
+  }
+
+  /**
+   * Select templates from the Template Registry API, via a cli table.
+   *
+   * @param {object} searchCriteria the Template Registry API search criteria
+   * @param {object} orderByCriteria the Template Registry API orderBy criteria
+   * @param {Array<object>} orgSupportedServices Services supported by the org
+   * @param {object} [templateRegistryConfig={}] the optional Template Registry API config
+   * @returns {Array<string>} an array of selected template module name(s)
+   */
+  async selectTemplates (searchCriteria, orderByCriteria, orgSupportedServices = undefined, templateRegistryConfig = {}) {
+    aioLogger.debug('searchCriteria', JSON.stringify(searchCriteria, null, 2))
+    aioLogger.debug('orderByCriteria', JSON.stringify(orderByCriteria, null, 2))
+    let supportedServiceCodes
+    if (orgSupportedServices) {
+      supportedServiceCodes = new Set(orgSupportedServices.map(s => s.code))
+    }
+
+    const spinner = ora()
+    spinner.start('Getting available templates')
+
+    const templateList = await this.getTemplates(searchCriteria, orderByCriteria, templateRegistryConfig)
+    aioLogger.debug('templateList', JSON.stringify(templateList, null, 2))
+    spinner.succeed('Downloaded the list of templates')
+
+    if (templateList.length === 0) {
+      throw new Error('There are no templates that match the query for selection')
+    }
+
+    const { columns: terminalColumns } = terminalSize()
+
+    const colPadding = 3
+    const colWidths = [
+      Math.round(0.3 * terminalColumns) - colPadding,
+      Math.round(0.3 * terminalColumns) - colPadding,
+      Math.round(0.2 * terminalColumns) - colPadding,
+      Math.round(0.2 * terminalColumns) - colPadding]
+
+    const COLUMNS = {
+      COL_TEMPLATE: 'Template',
+      COL_DESCRIPTION: 'Description',
+      COL_EXTENSION_POINT: 'Extension Point',
+      COL_CATEGORIES: 'Categories'
+    }
+
+    const rows = templateList.map(template => {
+      const extensionPoint = template.extensions ? template.extensions.map(ext => ext.extensionPointId).join(',') : 'N/A'
+      const name = template.adobeRecommended ? `${template.name} *` : template.name
+      let disabled = false
+      if (template.apis && supportedServiceCodes) {
+        disabled = !template.apis.map(api => api.code).every(code => supportedServiceCodes.has(code))
+      }
+      return {
+        value: template.name,
+        disabled,
+        [COLUMNS.COL_TEMPLATE]: name,
+        [COLUMNS.COL_DESCRIPTION]: template.description,
+        [COLUMNS.COL_EXTENSION_POINT]: extensionPoint,
+        [COLUMNS.COL_CATEGORIES]: template?.categories?.join(', ')
+      }
+    })
+    const promptName = 'select template'
+
+    inquirer.registerPrompt('table', inquirerTableCheckbox)
+    const answers = await inquirer
+      .prompt([
+        {
+          type: 'table',
+          name: promptName,
+          bottomContent: `* = recommended by Adobe; to learn more about the templates, go to ${hyperlinker('https://adobe.ly/templates', 'https://adobe.ly/templates')}`,
+          message: 'Choose the template(s) to install:',
+          style: { head: [], border: [] },
+          wordWrap: true,
+          wrapOnWordBoundary: false,
+          colWidths,
+          columns: [
+            { name: COLUMNS.COL_TEMPLATE },
+            { name: COLUMNS.COL_DESCRIPTION, wrapOnWordBoundary: true },
+            { name: COLUMNS.COL_EXTENSION_POINT },
+            { name: COLUMNS.COL_CATEGORIES, wrapOnWordBoundary: false }
+          ],
+          rows
+        }
+      ])
+
+    return answers[promptName]
+  }
+
+  /**
+   * Install the templates.
+   *
+   * @param {object} templateData the template data
+   * @param {boolean} [templateData.useDefaultValues=false] use default values when installing the template
+   * @param {boolean} [templateData.installConfig=true] process the install.yml of the template
+   * @param {boolean} [templateData.installNpm=true] run npm install after installing the template
+   * @param {object} [templateData.templateOptions=null] set the template options for installation
+   * @param {Array} templateData.templates the list of templates to install
+   */
+  async installTemplates ({
+    useDefaultValues = false,
+    installConfig = true,
+    installNpm = true,
+    templateOptions = null,
+    templates = []
+  } = {}) {
+    const spinner = ora()
+
+    // install the templates in sequence
+    for (const template of templates) {
+      spinner.info(`Installing template ${template}`)
+      const installArgs = [template]
+      if (useDefaultValues) {
+        installArgs.push('--yes')
+      }
+      if (!installConfig) {
+        installArgs.push('--no-process-install-config')
+      }
+      if (!installNpm) {
+        installArgs.push('--no-install')
+      }
+
+      if (templateOptions) {
+        if (typeof templateOptions !== 'object' || Array.isArray(templateOptions)) { // must be a non-array object
+          aioLogger.debug('malformed templateOptions', templateOptions)
+          throw new Error('The templateOptions is not a JavaScript object.')
+        }
+        const jsonString = JSON.stringify(templateOptions)
+        installArgs.push(`--template-options=${Buffer.from(jsonString).toString('base64')}`)
+      }
+
+      await this.config.runCommand('templates:install', installArgs)
+      spinner.succeed(`Installed template ${template}`)
+    }
+  }
+
+  /** @private */
+  _uniqueArray (array) {
+    return Array.from(new Set(array))
+  }
+
+  /**
+   * Get templates by extension point ids.
+   *
+   * @param {Array<string>} extensionsToInstall an array of extension point ids to install.
+   * @param {object} [templateRegistryConfig={}] the optional Template Registry API config
+   * @returns {object} returns the result
+   */
+  async getTemplatesByExtensionPointIds (extensionsToInstall, templateRegistryConfig = {}) {
+    const orderByCriteria = {
+      [TemplateRegistryAPI.ORDER_BY_CRITERIA_PUBLISH_DATE]: TemplateRegistryAPI.ORDER_BY_CRITERIA_SORT_DESC
+    }
+
+    const searchCriteria = {
+      [TemplateRegistryAPI.SEARCH_CRITERIA_STATUSES]: TemplateRegistryAPI.TEMPLATE_STATUS_APPROVED,
+      [TemplateRegistryAPI.SEARCH_CRITERIA_EXTENSIONS]: extensionsToInstall
+    }
+
+    const templates = await this.getTemplates(searchCriteria, orderByCriteria, templateRegistryConfig)
+    aioLogger.debug('templateList', JSON.stringify(templates, null, 2))
+
+    // check whether we got all extensions
+    const found = this._uniqueArray(templates
+      .map(t => t.extensions.map(e => e.extensionPointId)) // array of array of extensionPointIds
+      .filter(ids => extensionsToInstall.some(item => ids.includes(item)))
+      .flat()
+    )
+
+    const notFound = this._uniqueArray(extensionsToInstall).filter(ext => !found.includes(ext))
+
+    return {
+      found,
+      notFound,
+      templates
+    }
+  }
+
+  /**
+   * Install templates by extension point ids.
+   *
+   * @param {Array<string>} extensionsToInstall an array of extension point ids to install.
+   * @param {Array<string>} extensionsAlreadyImplemented an array of extension point ids that have already been implemented (to filter)
+   * @param {boolean} [useDefaultValues=false] use default values when installing the template
+   * @param {boolean} [installNpm=true] run npm install after installing the template
+   * @param {object} [templateRegistryConfig={}] the optional Template Registry API config
+   */
+  async installTemplatesByExtensionPointIds (extensionsToInstall, extensionsAlreadyImplemented, useDefaultValues = false, installNpm = true, templateRegistryConfig = {}) {
+    // no prompt
+    const alreadyThere = extensionsToInstall.filter(i => extensionsAlreadyImplemented.includes(i))
+    if (alreadyThere.length > 0) {
+      throw new Error(`'${alreadyThere.join(', ')}' extension(s) are already implemented in this project.`)
+    }
+
+    const { found, notFound, templates } = await this.getTemplatesByExtensionPointIds(extensionsToInstall, templateRegistryConfig)
+
+    if (notFound.length > 0) {
+      this.error(`Extension(s) '${notFound.join(', ')}' not found in the Template Registry.`)
+    }
+
+    this.log(`Extension(s) '${found.join(', ')}' found in the Template Registry. Installing...`)
+    await this.installTemplates({
+      useDefaultValues,
+      installNpm,
+      templates: templates.map(t => t.name)
+    })
+  }
+}
+
+TemplatesCommand.flags = {
+  ...AddCommand.flags
+}
+
+module.exports = TemplatesCommand

package/src/commands/app/add/action.js

@@ -9,22 +9,19 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const AddCommand = require('../../../AddCommand')
-const yeoman = require('yeoman-environment')
+const TemplatesCommand = require('../../../TemplatesCommand')
 const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:add:action', { provider: 'debug' })
 const { Flags } = require('@oclif/core')
-const ora = require('ora')
 const path = require('path')
-const generators = require('@adobe/generator-aio-app')
-const { servicesToGeneratorInput } = require('../../../lib/app-helper')
 const aioConfigLoader = require('@adobe/aio-lib-core-config')
+const TemplateRegistryAPI = require('@adobe/aio-lib-templates')
+const inquirer = require('inquirer')
 
-class AddActionCommand extends AddCommand {
+class AddActionCommand extends TemplatesCommand {
   async run () {
     const { flags } = await this.parse(AddActionCommand)
 
     aioLogger.debug(`add actions with flags: ${JSON.stringify(flags)}`)
-    const spinner = ora()
 
     // guaranteed to have at least one, otherwise would throw in config load or in matching the ext name
     const entries = Object.entries(this.getAppExtConfigs(flags))
@@ -35,33 +32,90 @@ class AddActionCommand extends AddCommand {
     const config = entries[0][1]
 
     const actionFolder = path.relative(config.root, config.actions.src)
-
     const configData = this.getRuntimeManifestConfigFile(configName)
 
-    // NOTE: we could get fresh data from console if we know that user is logged in
-    const workspaceServices =
-      aioConfigLoader.get('services') || // legacy
-      aioConfigLoader.get('project.workspace.details.services') ||
-      []
-    const supportedOrgServices = aioConfigLoader.get('project.org.details.services') || []
-
-    const env = yeoman.createEnv()
-    // by default yeoman runs the install, we control installation from the app plugin
-    env.options = { skipInstall: true }
-    const addActionGen = env.instantiate(generators['add-action'], {
-      options: {
-        'skip-prompt': flags.yes,
-        'action-folder': actionFolder,
-        'config-path': configData.file,
-        'adobe-services': servicesToGeneratorInput(workspaceServices),
-        'supported-adobe-services': servicesToGeneratorInput(supportedOrgServices),
-        'full-key-to-manifest': configData.key
-        // force: true
+    const projectOrgId = aioConfigLoader.get('project.org.id')
+    if (!projectOrgId) {
+      this.error(`Incomplete .aio configuration, please import a valid Adobe Developer Console configuration via \`${this.config.bin} app use\` first.`)
+    }
+
+    const consoleCLI = await this.getLibConsoleCLI()
+    const orgSupportedServices = await consoleCLI.getEnabledServicesForOrg(projectOrgId)
+
+    const templateOptions = {
+      'skip-prompt': flags.yes,
+      'action-folder': actionFolder,
+      'config-path': configData.file,
+      'full-key-to-manifest': configData.key
+    }
+
+    const [searchCriteria, orderByCriteria] = await this.getSearchCriteria(orgSupportedServices)
+    const templates = await this.selectTemplates(searchCriteria, orderByCriteria, orgSupportedServices)
+    if (templates.length === 0) {
+      this.error('No action templates were chosen to be installed.')
+    } else {
+      await this.installTemplates({
+        useDefaultValues: flags.yes,
+        installNpm: flags.install,
+        templateOptions,
+        templates
+      })
+    }
+  }
+
+  async getSearchCriteria (orgSupportedServices) {
+    const choices = [
+      {
+        name: 'All Action Templates',
+        value: 'allActionTemplates',
+        checked: true
       }
-    })
-    await env.runGenerator(addActionGen)
+    ]
+
+    if (orgSupportedServices) {
+      choices.push({
+        name: 'Only Action Templates Supported By My Org',
+        value: 'orgActionTemplates',
+        checked: false
+      })
+    }
+
+    const { components: selection } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'components',
+        message: 'What action templates do you want to search for?',
+        loop: false,
+        choices
+      }
+    ])
+
+    const TEMPLATE_CATEGORIES = ['action', 'helper-template']
+    const searchCriteria = {
+      [TemplateRegistryAPI.SEARCH_CRITERIA_STATUSES]: TemplateRegistryAPI.TEMPLATE_STATUS_APPROVED,
+      [TemplateRegistryAPI.SEARCH_CRITERIA_CATEGORIES]: TEMPLATE_CATEGORIES,
+      [TemplateRegistryAPI.SEARCH_CRITERIA_EXTENSIONS]: TemplateRegistryAPI.SEARCH_CRITERIA_FILTER_NONE
+    }
+
+    switch (selection) {
+      case 'orgActionTemplates': {
+        const supportedServiceCodes = new Set(orgSupportedServices.map(s => `|${s.code}`)) // | symbol denotes an OR clause
+        searchCriteria[TemplateRegistryAPI.SEARCH_CRITERIA_APIS] = Array.from(supportedServiceCodes)
+      }
+        break
+      case 'allActionTemplates':
+      default:
+        break
+    }
+
+    const { name: selectionLabel } = choices.find(item => item.value === selection)
+
+    // an optional OrderBy Criteria object
+    const orderByCriteria = {
+      [TemplateRegistryAPI.ORDER_BY_CRITERIA_PUBLISH_DATE]: TemplateRegistryAPI.ORDER_BY_CRITERIA_SORT_DESC
+    }
 
-    await this.runInstallPackages(flags, spinner)
+    return [searchCriteria, orderByCriteria, selection, selectionLabel]
   }
 }
 
@@ -80,7 +134,7 @@ AddActionCommand.flags = {
     multiple: false,
     parse: str => [str]
   }),
-  ...AddCommand.flags
+  ...TemplatesCommand.flags
 }
 
 AddActionCommand.aliases = ['app:add:actions']

package/src/commands/app/add/extension.js

@@ -9,107 +9,57 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const AddCommand = require('../../../AddCommand')
-const yeoman = require('yeoman-environment')
+const TemplatesCommand = require('../../../TemplatesCommand')
 const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:add:action', { provider: 'debug' })
 const { Flags } = require('@oclif/core')
-const ora = require('ora')
+const TemplateRegistryAPI = require('@adobe/aio-lib-templates')
 
-const { atLeastOne } = require('../../../lib/app-helper')
-const aioConfigLoader = require('@adobe/aio-lib-core-config')
-const { implPromptChoices } = require('../../../lib/defaults')
-const chalk = require('chalk')
-
-class AddExtensionCommand extends AddCommand {
+class AddExtensionCommand extends TemplatesCommand {
   async run () {
     const { flags } = await this.parse(AddExtensionCommand)
 
     aioLogger.debug(`add extensions with flags: ${JSON.stringify(flags)}`)
-    const spinner = ora()
 
     if (flags.yes && !flags.extension) {
       this.error('--extension= must also be provided when using --yes')
     }
 
     const fullConfig = this.getFullConfig({ allowNoImpl: true })
-    const implementationsToAdd = await this.selectImplementations(flags, fullConfig)
-
-    await this.runCodeGenerators(flags, implementationsToAdd)
-
-    await this.runInstallPackages(flags, spinner)
+    const alreadyImplemented = fullConfig.implements
 
-    // warn about services to add
-    const workspaceServices =
-      aioConfigLoader.get('services') || // legacy
-      aioConfigLoader.get('project.workspace.details.services') ||
-      []
-
-    const supportedServiceCodesInWorkspace = new Set(workspaceServices.map(s => s.code))
-    implementationsToAdd.forEach(i => {
-      const missingServices = i.requiredServices.filter(s => !supportedServiceCodesInWorkspace.has(s))
-      if (missingServices.length > 0) {
-        this.warn(`Please add missing services '${missingServices}' required by '${i.name}'`)
-      }
-    })
+    if (flags.extension) {
+      await this.installTemplatesByExtensionPointIds(flags.extension, alreadyImplemented, flags.yes, flags.install)
+    } else {
+      await this.selectExtensionsToInstall(alreadyImplemented, flags.yes, flags.install)
+    }
   }
 
-  async selectImplementations (flags, config) {
-    const alreadyImplemented = config.implements
-    const availableChoices = implPromptChoices
-    const availableImplementations = availableChoices.map(i => i.value.name)
+  async selectExtensionsToInstall (alreadyImplemented, useDefaultValues, installNpm) {
+    const excludeExtensions = alreadyImplemented.map(e => `${TemplateRegistryAPI.SEARCH_CRITERIA_FILTER_NOT}${e}`)
 
-    const possibleChoices = availableChoices.filter(i => !alreadyImplemented.includes(i.value.name))
-    if (possibleChoices.length <= 0) {
-      throw new Error('All available extensions are already implemented in this project.')
+    const orderByCriteria = {
+      [TemplateRegistryAPI.ORDER_BY_CRITERIA_PUBLISH_DATE]: TemplateRegistryAPI.ORDER_BY_CRITERIA_SORT_DESC
     }
 
-    if (flags.extension) {
-      // no prompt
-      const alreadyThere = flags.extension.filter(i => alreadyImplemented.includes(i))
-      if (alreadyThere.length > 0) {
-        throw new Error(`'${alreadyThere}' is/are already implemented by this project`)
-      }
-      const invalid = flags.extension.filter(i => !availableImplementations.includes(i))
-      if (invalid.length > 0) {
-        throw new Error(`Invalid extension(s) '${invalid}', available implementations are '${availableImplementations}'`)
-      }
-
-      return flags.extension.map(i => possibleChoices.find(c => c.value.name === i).value)
+    const searchCriteria = {
+      [TemplateRegistryAPI.SEARCH_CRITERIA_STATUSES]: TemplateRegistryAPI.TEMPLATE_STATUS_APPROVED,
+      [TemplateRegistryAPI.SEARCH_CRITERIA_EXTENSIONS]: excludeExtensions
     }
 
-    // prompt
-    const answers = await this.prompt([{
-      type: 'checkbox',
-      name: 'res',
-      message: 'Which new implementation(s) do you wish to add to the project ?',
-      choices: possibleChoices,
-      validate: atLeastOne
-    }])
-
-    return answers.res
-  }
-
-  async runCodeGenerators (flags, implementations) {
-    const env = yeoman.createEnv()
-    // by default yeoman runs the install, we control installation from the app plugin
-    env.options = { skipInstall: true }
-    for (let i = 0; i < implementations.length; ++i) {
-      const implementation = implementations[i]
-      const gen = env.instantiate(implementation.generator,
-        {
-          options: {
-            'skip-prompt': flags.yes,
-            // no yeoman overwrite prompts
-            force: true
-          }
-        })
-      this.log(chalk.blue(chalk.bold(`Running generator for ${implementation.name}`)))
-      await env.runGenerator(gen)
+    const templates = await this.selectTemplates(searchCriteria, orderByCriteria)
+    if (templates.length === 0) {
+      this.error('No extensions were chosen to be installed.')
+    } else {
+      await this.installTemplates({
+        useDefaultValues,
+        installNpm,
+        templates
+      })
     }
   }
 }
 
-AddExtensionCommand.description = `Add new extensions or a standalone application to the project
+AddExtensionCommand.description = `Add new extensions to the project
 `
 AddExtensionCommand.flags = {
   yes: Flags.boolean({
@@ -122,7 +72,7 @@ AddExtensionCommand.flags = {
     char: 'e',
     multiple: true
   }),
-  ...AddCommand.flags
+  ...TemplatesCommand.flags
 }
 
 AddExtensionCommand.aliases = ['app:add:ext', 'app:add:extensions']

package/src/commands/app/add/service.js

@@ -37,7 +37,7 @@ class AddServiceCommand extends BaseCommand {
     // load console configuration from .aio and .env files
     const projectConfig = config.get('project')
     if (!projectConfig) {
-      this.error('Incomplete .aio configuration, please import a valid Adobe Developer Console configuration via `aio app use` first.')
+      this.error(`Incomplete .aio configuration, please import a valid Adobe Developer Console configuration via \`${this.config.bin} app use\` first.`)
     }
     const orgId = projectConfig.org.id
     const project = { name: projectConfig.name, id: projectConfig.id }

package/src/commands/app/add/web-assets.js

@@ -9,19 +9,14 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const AddCommand = require('../../../AddCommand')
-const yeoman = require('yeoman-environment')
+const TemplatesCommand = require('../../../TemplatesCommand')
 const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:add:web-assets', { provider: 'debug' })
 const { Flags } = require('@oclif/core')
-const ora = require('ora')
-const generators = require('@adobe/generator-aio-app')
-const aioConfigLoader = require('@adobe/aio-lib-core-config')
-const { servicesToGeneratorInput } = require('../../../lib/app-helper')
+const TemplateRegistryAPI = require('@adobe/aio-lib-templates')
 
-class AddWebAssetsCommand extends AddCommand {
+class AddWebAssetsCommand extends TemplatesCommand {
   async run () {
     const { flags } = await this.parse(AddWebAssetsCommand)
-    const spinner = ora()
     aioLogger.debug(`add web-assets with flags: ${JSON.stringify(flags)}`)
 
     const projectName = this.getFullConfig().packagejson.name
@@ -33,26 +28,32 @@ class AddWebAssetsCommand extends AddCommand {
     const config = entries[0][1]
     const webSrcFolder = config.web.src
 
-    const workspaceServices =
-      aioConfigLoader.get('services') || // legacy
-      aioConfigLoader.get('project.workspace.details.services') ||
-      []
-
-    const env = yeoman.createEnv()
-    // by default yeoman runs the install, we control installation from the app plugin
-    env.options = { skipInstall: true }
-    const gen = env.instantiate(generators['add-web-assets'], {
-      options: {
-        'skip-prompt': flags.yes,
-        'project-name': projectName,
-        'web-src-folder': webSrcFolder,
-        'adobe-services': servicesToGeneratorInput(workspaceServices)
-        // force: true
-      }
-    })
-    await env.runGenerator(gen)
+    const templateOptions = {
+      'skip-prompt': flags.yes,
+      'project-name': projectName,
+      'web-src-folder': webSrcFolder
+    }
 
-    await this.runInstallPackages(flags, spinner)
+    const TEMPLATE_CATEGORIES = ['ui', 'helper-template']
+    const searchCriteria = {
+      [TemplateRegistryAPI.SEARCH_CRITERIA_STATUSES]: TemplateRegistryAPI.TEMPLATE_STATUS_APPROVED,
+      [TemplateRegistryAPI.SEARCH_CRITERIA_CATEGORIES]: TEMPLATE_CATEGORIES,
+      [TemplateRegistryAPI.SEARCH_CRITERIA_EXTENSIONS]: TemplateRegistryAPI.SEARCH_CRITERIA_FILTER_NONE
+    }
+    const orderByCriteria = {
+      [TemplateRegistryAPI.ORDER_BY_CRITERIA_PUBLISH_DATE]: TemplateRegistryAPI.ORDER_BY_CRITERIA_SORT_DESC
+    }
+    const templates = await this.selectTemplates(searchCriteria, orderByCriteria)
+    if (templates.length === 0) {
+      this.error('No web-asset templates were chosen to be installed.')
+    } else {
+      await this.installTemplates({
+        useDefaultValues: flags.yes,
+        installNpm: flags.install,
+        templateOptions,
+        templates
+      })
+    }
   }
 }
 
@@ -71,7 +72,7 @@ AddWebAssetsCommand.flags = {
     multiple: false,
     parse: str => [str]
   }),
-  ...AddCommand.flags
+  ...TemplatesCommand.flags
 }
 
 AddWebAssetsCommand.args = []

package/src/commands/app/build.js

@@ -26,8 +26,7 @@ class Build extends BaseCommand {
     // cli input
     const { flags } = await this.parse(Build)
     // flags
-    flags['web-assets'] = flags['web-assets'] && !flags['skip-static'] && !flags['skip-web-assets'] && !flags.action
-    flags.actions = flags.actions && !flags['skip-actions']
+    flags['web-assets'] = flags['web-assets'] && !flags.action
 
     const buildConfigs = this.getAppExtConfigs(flags)
 
@@ -144,15 +143,6 @@ This will always force a rebuild unless --no-force-build is set.
 
 Build.flags = {
   ...BaseCommand.flags,
-  'skip-static': Flags.boolean({
-    description: '[deprecated] Please use --no-web-assets'
-  }),
-  'skip-web-assets': Flags.boolean({
-    description: '[deprecated] Please use --no-web-assets'
-  }),
-  'skip-actions': Flags.boolean({
-    description: '[deprecated] Please use --no-actions'
-  }),
   actions: Flags.boolean({
     description: '[default: true] Build actions if any',
     default: true,