Nw hackdays37 extension workflow registry

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

@@ -79,7 +79,6 @@
   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) =>
@@ -101,7 +100,7 @@
   // 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,
@@ -109,7 +108,7 @@
     // 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}
 }
@@ -157,4 +156,4 @@
 }
 
 export default generateExtensionPrompts
 export {promptAddExtensionConfirmation}

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

@@ -1,10 +1,10 @@
 import {fetchExtensionTemplates} from './generate/fetch-template-specifications.js'
+import {workflowRegistry, WorkflowResult} from './generate/workflows/registry.js'
 import {DeveloperPlatformClient} from '../utilities/developer-platform-client.js'
 import {AppInterface, AppLinkedInterface} from '../models/app/app.js'
 import generateExtensionPrompts, {
   GenerateExtensionPromptOptions,
   GenerateExtensionPromptOutput,
-  promptAddExtensionConfirmation,
 } from '../prompts/generate/extension.js'
 import metadata from '../metadata.js'
 import {
@@ -24,7 +24,7 @@
 import {formatPackageManagerCommand} from '@shopify/cli-kit/node/output'
 import {groupBy} from '@shopify/cli-kit/common/collection'
 
-interface GenerateOptions {
+export interface GenerateOptions {
   app: AppLinkedInterface
   specifications: RemoteAwareExtensionSpecification[]
   remoteApp: OrganizationApp
@@ -40,62 +40,35 @@
 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)
-  // Here we could check if the user wants to add a related extension
-  const addPromptConfirmation = await promptAddExtensionConfirmation()
+
   // We can add an extra generated extension here.
   const generateExtensionOptions = buildGenerateOptions(promptAnswers, app, options, developerPlatformClient)
   const generatedExtension = await generateExtensionTemplate(generateExtensionOptions)
 
-  // 1. Generate ui extension
-  // 2. We check the identifier
-  // 3. If the identifier has related extensions then the team who owns can add logic to add related extensions
-  // 4. This allows new prompts
-  // 4.1. Generate function settings
-  // 4.2. Function settings is meant to be used with a discount function, would you like us to generate one for you?
-  // 4.3. What is the name of your function?
-  // Generates both extensions
-  if (addPromptConfirmation) {
-    // Generate related extensions
-    const generateExtensionOptions = buildGenerateOptions(promptAnswers, app, options, developerPlatformClient)
-    const generatedExtension = await generateExtensionTemplate(generateExtensionOptions)
+  const workflow = workflowRegistry[generatedExtension.extensionTemplate.identifier]
+  if (!workflow) {
+    renderSuccessMessage(generatedExtension, app.packageManager)
+  }
+
+  const workflowResult = await workflow?.afterGenerate({
+    generateOptions: options,
+    extensionTemplateOptions: generateExtensionOptions,
+    generatedExtension,
+  })
+
+  if (!workflowResult?.success) {
+    //TODO: Cleanup extension?
   }
 
-  renderSuccessMessage(generatedExtension, app.packageManager)
+  renderSuccessMessage(generatedExtension, app.packageManager, workflowResult)
 }
 
 async function buildPromptOptions(
@@ -104,7 +77,6 @@
   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)
 
@@ -136,16 +108,14 @@
 }
 
 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})
   return existingExtensions.length >= (specification?.registrationLimit || 1)
 }
 
 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,
@@ -168,11 +138,12 @@
   }
 }
 
-function renderSuccessMessage(extension: GeneratedExtension, packageManager: AppInterface['packageManager']) {
+function renderSuccessMessage(extension: GeneratedExtension, packageManager: AppInterface['packageManager'], workflowResult?: WorkflowResult) {
   const formattedSuccessfulMessage = formatSuccessfulRunMessage(
     extension.extensionTemplate,
     extension.directory,
     packageManager,
+    workflowResult,
   )
   renderSuccess(formattedSuccessfulMessage)
 }
@@ -194,11 +165,13 @@
   extensionTemplate: ExtensionTemplate,
   extensionDirectory: string,
   depndencyManager: PackageManager,
+  workflowResult?: WorkflowResult,
 ): RenderAlertOptions {
+  const workflowMessage = workflowResult?.message
   const options: RenderAlertOptions = {
-    headline: ['Your extension was created in', {filePath: extensionDirectory}, {char: '.'}],
-    nextSteps: [],
-    reference: [],
+    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/workflows/editor-extension-collection.ts

@@ -0,0 +1,28 @@
+import {Workflow} from './registry.js'
+import {joinPath} from '@shopify/cli-kit/node/path'
+import {renderTextPrompt} from '@shopify/cli-kit/node/ui'
+import {patchConfigurationFile} from './patch-configuration-file.js'
+
+export const editorExtensionCollection: Workflow = {
+  afterGenerate: async (options) => {
+    const existingExtensions = options.generateOptions.app.extensionsForType({
+      identifier: 'ui_extension',
+      externalIdentifier: 'ui_extension',
+    })
+    const availableExtensions = existingExtensions.map((extension) => extension.handle).join(' ')
+    const extensions = await renderTextPrompt({
+      message: `The extension handles to include in the collection, comma separated. Options: ${availableExtensions}`,
+    })
+    await patchConfigurationFile({
+      path: joinPath(options.generatedExtension.directory, 'shopify.extension.toml'),
+      patch: {
+        extensions: [{
+          includes: extensions.split(',').map((handle) => handle.trim())
+        }],
+      },
+    })
+    return {
+      success: true,
+    }
+  },
+}

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 patchConfigurationFile({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/registry.ts

@@ -0,0 +1,27 @@
+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'
+
+interface AfterGenerateOptions {
+  generateOptions: GenerateOptions
+  extensionTemplateOptions: GenerateExtensionTemplateOptions
+  generatedExtension: GeneratedExtension
+}
+
+export interface WorkflowResult {
+  success: boolean
+  message?: RenderAlertOptions
+}
+
+export interface Workflow {
+  afterGenerate: (options: AfterGenerateOptions) => Promise<WorkflowResult>
+}
+
+interface WorkflowRegistry {
+  [key: string]: Workflow
+}
+
+export const workflowRegistry: WorkflowRegistry = {
+  editor_extension_collection: editorExtensionCollection,
+}