Add workflow for discount function settings

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

@@ -73,13 +73,12 @@ export function buildChoices(extensionTemplates: ExtensionTemplate[], unavailabl
   return templateSpecChoices.sort(compareChoices)
 }
 
-const generateExtensionPrompts = async (
+export const generateExtensionPrompts = async (
   options: GenerateExtensionPromptOptions,
 ): Promise<GenerateExtensionPromptOutput> => {
   let extensionTemplates = options.extensionTemplates
   let templateType = options.templateType
   const extensionFlavor = options.extensionFlavor
-  console.log('EXTENSION TEMPLATES', extensionTemplates)
   if (!templateType) {
     if (extensionFlavor) {
       extensionTemplates = extensionTemplates.filter((template) =>
@@ -91,11 +90,15 @@ const generateExtensionPrompts = async (
       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
@@ -106,10 +109,7 @@ const generateExtensionPrompts = async (
   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}
 }

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

@@ -5,7 +5,6 @@ import {AppInterface, AppLinkedInterface} from '../models/app/app.js'
 import generateExtensionPrompts, {
   GenerateExtensionPromptOptions,
   GenerateExtensionPromptOutput,
-  promptAddExtensionConfirmation,
 } from '../prompts/generate/extension.js'
 import metadata from '../metadata.js'
 import {
@@ -41,63 +40,32 @@ export interface GenerateOptions {
 async function generate(options: GenerateOptions) {
   const {app, developerPlatformClient, remoteApp, specifications, template} = options
 
-  // console.log('GENERATE', options)
-
   const availableSpecifications = specifications.map((spec) => spec.identifier)
   const extensionTemplates = await fetchExtensionTemplates(developerPlatformClient, remoteApp, availableSpecifications)
 
   const promptOptions = await buildPromptOptions(extensionTemplates, specifications, app, options)
   const promptAnswers = await generateExtensionPrompts(promptOptions)
 
-  // Add related extension children for product discounts
-  if (promptAnswers.extensionTemplate.identifier === 'product_discounts') {
-    const settingsTemplate = extensionTemplates.find((template) => template.identifier === 'discount_function_settings')
-    if (settingsTemplate) {
-      const mockSettingsPromptAnswers: GenerateExtensionPromptOutput = {
-        extensionTemplate: settingsTemplate,
-        extensionContent: {
-          name: `${promptAnswers.extensionContent.name}-settings`,
-          flavor: 'react',
-          relatedExtensions: [],
-        },
-      }
-
-      // Generate the settings extension
-      const settingsGenerateOptions = buildGenerateOptions(
-        mockSettingsPromptAnswers,
-        app,
-        options,
-        developerPlatformClient,
-      )
-      await generateExtensionTemplate(settingsGenerateOptions)
-    }
-  }
-
-  console.log('PROMPT ANSWERS', promptAnswers)
-  // 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)
-
+  renderSuccessMessage(generatedExtension, app.packageManager)
   const workflow = workflowRegistry[generatedExtension.extensionTemplate.identifier]
   await workflow?.afterGenerate({
     generateOptions: options,
-    extensionTemplateOptions: generateExtensionOptions,
     generatedExtension,
+    extensionTemplateOptions: generateExtensionOptions,
+    extensionTemplates: extensionTemplates,
   })
-
-  renderSuccessMessage(generatedExtension, app.packageManager)
 }
 
-async function buildPromptOptions(
+export async function buildPromptOptions(
   extensionTemplates: ExtensionTemplate[],
   specifications: ExtensionSpecification[],
   app: AppInterface,
   options: GenerateOptions,
 ): Promise<GenerateExtensionPromptOptions> {
-  // console.log('BUILDING PROMPT OPTIONS', arguments)
   const extensionTemplate = await handleTypeParameter(options.template, app, extensionTemplates, specifications)
   validateExtensionFlavor(extensionTemplate, options.flavor)
 
@@ -129,7 +97,6 @@ function checkLimits(
 }
 
 function limitReached(app: AppInterface, specifications: ExtensionSpecification[], template: ExtensionTemplate) {
-  // console.log('CHECKING LIMITS', specifications)
   const type = template.type
   const specification = specifications.find((spec) => spec.identifier === type || spec.externalIdentifier === type)
   const existingExtensions = app.extensionsForType({identifier: type, externalIdentifier: type})
@@ -138,15 +105,14 @@ function limitReached(app: AppInterface, specifications: ExtensionSpecification[
 
 async function saveAnalyticsMetadata(promptAnswers: GenerateExtensionPromptOutput, typeFlag: string | undefined) {
   const {extensionContent} = promptAnswers
-  console.log('SAVING METADATA', promptAnswers)
   return metadata.addPublicMetadata(() => ({
     cmd_scaffold_template_flavor: extensionContent.flavor,
     cmd_scaffold_type: promptAnswers.extensionTemplate.identifier,
     cmd_scaffold_used_prompts_for_type: !typeFlag,
   }))
 }
 
-function buildGenerateOptions(
+export function buildGenerateOptions(
   promptAnswers: GenerateExtensionPromptOutput,
   app: AppInterface,
   options: GenerateOptions,
@@ -161,7 +127,7 @@ function buildGenerateOptions(
   }
 }
 
-function renderSuccessMessage(extension: GeneratedExtension, packageManager: AppInterface['packageManager']) {
+export function renderSuccessMessage(extension: GeneratedExtension, packageManager: AppInterface['packageManager']) {
   const formattedSuccessfulMessage = formatSuccessfulRunMessage(
     extension.extensionTemplate,
     extension.directory,

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

@@ -60,6 +60,7 @@ function getTemplateLanguage(flavor: ExtensionFlavorValue | undefined): Template
 export interface GeneratedExtension {
   directory: string
   extensionTemplate: ExtensionTemplate
+  handle: string
 }
 
 interface ExtensionInitOptions {
@@ -81,7 +82,6 @@ export async function generateExtensionTemplate(
   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
@@ -100,7 +100,11 @@ export async function generateExtensionTemplate(
       }),
   }
   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) {
@@ -225,7 +229,7 @@ async function uiExtensionInit({
   onGetTemplateRepository,
 }: ExtensionInitOptions) {
   const templateLanguage = getTemplateLanguage(extensionFlavor?.value)
-
+  console.log('extensionName', name)
   const tasks = [
     {
       title: `Generating extension`,

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

@@ -0,0 +1,40 @@
+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, renderSuccessMessage, buildPromptOptions} from '../../generate.js'
+import {GenerateExtensionPromptOutput} from '../../../prompts/generate/extension.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)
+      renderSuccessMessage(generatedExtension, app.packageManager)
+    }
+  },
+}

packages/app/src/cli/services/generate/workflows/patch-configuration-file.ts

@@ -0,0 +1,34 @@
+import {deepMergeObjects} from '@shopify/cli-kit/common/object'
+import {readFile, writeFile} from '@shopify/cli-kit/node/fs'
+import {zod} from '@shopify/cli-kit/node/schema'
+import {decodeToml, encodeToml} from '@shopify/cli-kit/node/toml'
+
+export interface PatchTomlOptions {
+  path: string
+  patch: {[key: string]: unknown}
+  schema?: zod.AnyZodObject
+}
+
+function mergeArrayStrategy(existingArray: unknown[], newArray: unknown[]): unknown[] {
+  if (
+    existingArray.length > 0 &&
+    existingArray[0] &&
+    typeof existingArray[0] === 'object' &&
+    newArray[0] &&
+    typeof newArray[0] === 'object'
+  ) {
+    return [{...(existingArray[0] as object), ...(newArray[0] as object)}]
+  }
+  return newArray
+}
+
+export async function patchAppConfigurationFile({path, patch}: PatchTomlOptions) {
+  const tomlContents = await readFile(path)
+  const configuration = decodeToml(tomlContents)
+
+  // Deep merge with custom array strategy
+  const updatedConfig = deepMergeObjects(configuration, patch, mergeArrayStrategy)
+
+  const encodedString = encodeToml(updatedConfig)
+  await writeFile(path, encodedString)
+}

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

@@ -0,0 +1,53 @@
+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, renderSuccessMessage, buildPromptOptions} from '../../generate.js'
+import {GenerateExtensionPromptOutput} from '../../../prompts/generate/extension.js'
+import {patchAppConfigurationFile} 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 a UI extension for your function?',
+      defaultValue: true,
+    })
+
+    if (shouldLinkExtension) {
+      // 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)
+      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 patchAppConfigurationFile({
+        path: functionTomlFilePath,
+        patch,
+      })
+      renderSuccessMessage(generatedExtension, app.packageManager)
+    }
+  },
+}

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

@@ -1,10 +1,14 @@
 import {editorExtensionCollection} from './editor-extension-collection.js'
 import {GenerateOptions} from '../../generate.js'
 import {GeneratedExtension, GenerateExtensionTemplateOptions} from '../../generate/extension.js'
+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
 }
 
@@ -18,4 +22,6 @@ interface WorkflowRegistry {
 
 export const workflowRegistry: WorkflowRegistry = {
   editor_extension_collection: editorExtensionCollection,
+  discount_details_function_settings: discountDetailsFunctionSettingsCollection,
+  product_discounts: productDiscountFunctionCollection,
 }