Add workflow for discount function settings

packages/app/src/cli/prompts/generate/extension.ts

@@ -73,7 +73,7 @@
   return templateSpecChoices.sort(compareChoices)
 }
 
-const generateExtensionPrompts = async (
+export const generateExtensionPrompts = async (
   options: GenerateExtensionPromptOptions,
 ): Promise<GenerateExtensionPromptOutput> => {
   let extensionTemplates = options.extensionTemplates
@@ -90,25 +90,26 @@
       throw new AbortError('You have reached the limit for the number of extensions you can create.')
     }
 
-    // eslint-disable-next-line require-atomic-updates
-    templateType = await renderAutocompletePrompt({
-      message: 'Type of extension?',
-      choices: buildChoices(extensionTemplates, options.unavailableExtensions),
-    })
+    if (extensionTemplates.length === 1) {
+      templateType = extensionTemplates[0]?.identifier
+    } else {
+      // eslint-disable-next-line require-atomic-updates
+      templateType = await renderAutocompletePrompt({
+        message: 'Type of extension?',
+        choices: buildChoices(extensionTemplates, options.unavailableExtensions),
+      })
+    }
   }
 
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const extensionTemplate = extensionTemplates.find((template) => template.identifier === templateType)!
 
   const name = options.name || (await promptName(options.directory, extensionTemplate.defaultName))
   const flavor = options.extensionFlavor ?? (await promptFlavor(extensionTemplate))
   const extensionContent = {
     name,
     flavor,
-    // extensionChildren [identifiers]
-    extensionChildren: extensionTemplate.relatedExtensions?.map((elem) => elem.name) ?? [],
   }
-  // TODO: here perhaps return a flag, that lets us know that there are possible next steps
 
   return {extensionTemplate, extensionContent}
 }
@@ -155,5 +156,5 @@
   })
 }
 
 export default generateExtensionPrompts
 export {promptAddExtensionConfirmation}

packages/app/src/cli/services/generate.ts

@@ -46,10 +46,8 @@
   const promptOptions = await buildPromptOptions(extensionTemplates, specifications, app, options)
   const promptAnswers = await generateExtensionPrompts(promptOptions)
 
-  // Call module related to that child extension
   await saveAnalyticsMetadata(promptAnswers, template)
 
-  // We can add an extra generated extension here.
   const generateExtensionOptions = buildGenerateOptions(promptAnswers, app, options, developerPlatformClient)
   const generatedExtension = await generateExtensionTemplate(generateExtensionOptions)
 
@@ -60,18 +58,19 @@
 
   const workflowResult = await workflow?.afterGenerate({
     generateOptions: options,
-    extensionTemplateOptions: generateExtensionOptions,
     generatedExtension,
+    extensionTemplateOptions: generateExtensionOptions,
+    extensionTemplates,
   })
 
   if (!workflowResult?.success) {
     //TODO: Cleanup extension?
   }
 
   renderSuccessMessage(generatedExtension, app.packageManager, workflowResult)
 }
 
-async function buildPromptOptions(
+export async function buildPromptOptions(
   extensionTemplates: ExtensionTemplate[],
   specifications: ExtensionSpecification[],
   app: AppInterface,
@@ -111,7 +110,7 @@
   const type = template.type
   const specification = specifications.find((spec) => spec.identifier === type || spec.externalIdentifier === type)
   const existingExtensions = app.extensionsForType({identifier: type, externalIdentifier: type})
   return existingExtensions.length >= (specification?.registrationLimit || 1)
 }
 
 async function saveAnalyticsMetadata(promptAnswers: GenerateExtensionPromptOutput, typeFlag: string | undefined) {
@@ -123,7 +122,7 @@
   }))
 }
 
-function buildGenerateOptions(
+export function buildGenerateOptions(
   promptAnswers: GenerateExtensionPromptOutput,
   app: AppInterface,
   options: GenerateOptions,
@@ -138,7 +137,11 @@
   }
 }
 
-function renderSuccessMessage(extension: GeneratedExtension, packageManager: AppInterface['packageManager'], workflowResult?: WorkflowResult) {
+function renderSuccessMessage(
+  extension: GeneratedExtension,
+  packageManager: AppInterface['packageManager'],
+  workflowResult?: WorkflowResult,
+) {
   const formattedSuccessfulMessage = formatSuccessfulRunMessage(
     extension.extensionTemplate,
     extension.directory,
@@ -169,9 +172,13 @@
 ): RenderAlertOptions {
   const workflowMessage = workflowResult?.message
   const options: RenderAlertOptions = {
-    headline: workflowMessage?.headline || ['Your extension was created in', {filePath: extensionDirectory}, {char: '.'}],
+    headline: workflowMessage?.headline || [
+      'Your extension was created in',
+      {filePath: extensionDirectory},
+      {char: '.'},
+    ],
     nextSteps: workflowMessage?.nextSteps || [],
     reference: workflowMessage?.reference || [],
   }
 
   if (extensionTemplate.type !== 'function') {

packages/app/src/cli/services/generate/extension.ts

@@ -60,6 +60,7 @@
 export interface GeneratedExtension {
   directory: string
   extensionTemplate: ExtensionTemplate
+  handle: string
 }
 
 interface ExtensionInitOptions {
@@ -81,9 +82,8 @@
   const extensionFlavor = options.extensionTemplate.supportedFlavors.find(
     (flavor) => flavor.value === extensionFlavorValue,
   )
-  // TODO For grouping we might want to setup directories/groups for extensions
   const directory = await ensureExtensionDirectoryExists({app: options.app, name: extensionName})
   const url = options.cloneUrl || options.extensionTemplate.url
   const uid = options.developerPlatformClient.supportsAtomicDeployments ? randomUUID() : undefined
   const initOptions: ExtensionInitOptions = {
     directory,
@@ -100,7 +100,11 @@
       }),
   }
   await extensionInit(initOptions)
-  return {directory: relativizePath(directory), extensionTemplate: options.extensionTemplate}
+  return {
+    directory: relativizePath(directory),
+    extensionTemplate: options.extensionTemplate,
+    handle: slugify(extensionName),
+  }
 }
 
 async function extensionInit(options: ExtensionInitOptions) {
@@ -170,7 +174,7 @@
         await recursiveLiquidTemplateCopy(templateDirectory, directory, {
           name,
           handle: slugify(name),
           // TODO: This is where we'd want to write the ui extension handle in the function toml
           uiExtensionHandle: slugify(name),
           flavor: extensionFlavor?.value,
           uid,
@@ -178,7 +182,7 @@
       })
 
       if (templateLanguage === 'javascript') {
         const srcFileExtension = getSrcFileExtension(extensionFlavor?.value || 'rust')
         await changeIndexFileExtension(directory, srcFileExtension, '!(*.graphql)')
       }
     },
@@ -225,7 +229,6 @@
   onGetTemplateRepository,
 }: ExtensionInitOptions) {
   const templateLanguage = getTemplateLanguage(extensionFlavor?.value)
-
   const tasks = [
     {
       title: `Generating extension`,

packages/app/src/cli/services/generate/workflows/discount-details-function-settings-collection.ts

@@ -0,0 +1,42 @@
+import {renderConfirmationPrompt} from '@shopify/cli-kit/node/ui'
+import {Workflow} from './registry.js'
+import {generateExtensionTemplate} from '../extension.js'
+import {generateExtensionPrompts} from '../../../prompts/generate/extension.js'
+import {buildGenerateOptions, buildPromptOptions} from '../../generate.js'
+
+export const discountDetailsFunctionSettingsCollection: Workflow = {
+  afterGenerate: async (options) => {
+    const {app, developerPlatformClient, specifications} = options.generateOptions
+
+    const shouldCreateFunction = await renderConfirmationPrompt({
+      message: 'Would you like to create a function for this extension?',
+      defaultValue: true,
+    })
+
+    if (shouldCreateFunction) {
+      // create a function extension
+      const extensionTemplates = options.extensionTemplates.filter(
+        (template) =>
+          template.identifier === 'shipping_discounts' ||
+          template.identifier === 'product_discounts' ||
+          template.identifier === 'order_discounts' ||
+          template.identifier == 'discounts_allocator',
+      )
+
+      const promptOptions = await buildPromptOptions(extensionTemplates, specifications, app, options.generateOptions)
+      const promptAnswers = await generateExtensionPrompts(promptOptions)
+
+      const generateExtensionOptions = buildGenerateOptions(
+        promptAnswers,
+        app,
+        options.generateOptions,
+        developerPlatformClient,
+      )
+      const generatedExtension = await generateExtensionTemplate(generateExtensionOptions)
+    }
+
+    return {
+      success: true,
+    }
+  },
+}

packages/app/src/cli/services/generate/workflows/product-discount-function-collection.ts

@@ -0,0 +1,71 @@
+import {renderConfirmationPrompt} from '@shopify/cli-kit/node/ui'
+import {Workflow} from './registry.js'
+import {generateExtensionTemplate} from '../extension.js'
+import {generateExtensionPrompts} from '../../../prompts/generate/extension.js'
+import {buildGenerateOptions, buildPromptOptions} from '../../generate.js'
+import {GenerateExtensionPromptOutput} from '../../../prompts/generate/extension.js'
+import {patchConfigurationFile} from './patch-configuration-file.js'
+
+export const productDiscountFunctionCollection: Workflow = {
+  afterGenerate: async (options) => {
+    const {app, developerPlatformClient, specifications} = options.generateOptions
+    const functionTomlFilePath = `${options.generatedExtension.directory}/shopify.extension.toml`
+
+    const shouldLinkExtension = await renderConfirmationPrompt({
+      message: 'Would you like to create an Admin UI for configuring your function?',
+      confirmationMessage: 'Yes (recommended)',
+      cancellationMessage: 'No',
+      defaultValue: true,
+    })
+
+    if (!shouldLinkExtension) {
+      return {
+        success: true,
+      }
+    }
+
+    // create a UI extension
+    const extensionTemplates = options.extensionTemplates.filter(
+      (template) => template.identifier === 'discount_details_function_settings',
+    )
+
+    const promptOptions = await buildPromptOptions(extensionTemplates, specifications, app, options.generateOptions)
+    // TODO: What if it's larger than the limit?
+    promptOptions.name = `${options.generatedExtension.handle}-ui`
+    const promptAnswers = await generateExtensionPrompts(promptOptions)
+    const generateExtensionOptions = buildGenerateOptions(
+      promptAnswers,
+      app,
+      options.generateOptions,
+      developerPlatformClient,
+    )
+    const generatedExtension = await generateExtensionTemplate(generateExtensionOptions)
+
+    const patch = {
+      extensions: [
+        {
+          ui: {
+            handle: generatedExtension.handle,
+          },
+        },
+      ],
+    }
+    await patchConfigurationFile({
+      path: functionTomlFilePath,
+      patch,
+    })
+
+    return {
+      success: true,
+      message: {
+        headline: [
+          'Your extensions were created in',
+          {filePath: options.generatedExtension.directory},
+          'and',
+          {filePath: generatedExtension.directory},
+          {char: '.'},
+        ],
+      }
+    }
+  },
+}

packages/app/src/cli/services/generate/workflows/registry.ts

@@ -1,11 +1,15 @@
 import {editorExtensionCollection} from './editor-extension-collection.js'
 import {GenerateOptions} from '../../generate.js'
 import {GeneratedExtension, GenerateExtensionTemplateOptions} from '../../generate/extension.js'
-import { RenderAlertOptions } from '@shopify/cli-kit/node/ui'
+import {RenderAlertOptions} from '@shopify/cli-kit/node/ui'
+import {discountDetailsFunctionSettingsCollection} from './discount-details-function-settings-collection.js'
+import {productDiscountFunctionCollection} from './product-discount-function-collection.js'
+import {ExtensionTemplate} from '../../../models/app/template.js'
 
 interface AfterGenerateOptions {
   generateOptions: GenerateOptions
   extensionTemplateOptions: GenerateExtensionTemplateOptions
+  extensionTemplates: ExtensionTemplate[]
   generatedExtension: GeneratedExtension
 }
 
@@ -24,4 +28,6 @@
 
 export const workflowRegistry: WorkflowRegistry = {
   editor_extension_collection: editorExtensionCollection,
+  discount_details_function_settings: discountDetailsFunctionSettingsCollection,
+  product_discounts: productDiscountFunctionCollection,
 }