Merge pull request #6124 from Shopify/jb-multi-env

Update multi-environment theme command behaviour

Author: dejmedus

.changeset/breezy-papayas-watch.md

@@ -0,0 +1,6 @@
+---
+'@shopify/theme': minor
+'@shopify/cli': minor
+---
+
+Allow multi-environment theme commands to accept flags from CLI

.changeset/dry-waves-agree.md

@@ -0,0 +1,6 @@
+---
+'@shopify/theme': minor
+'@shopify/cli': minor
+---
+
+Prompt for confirmation before running multi-environment theme commands that allow `--force` flag

packages/theme/src/cli/utilities/theme-command.test.ts

@@ -1,14 +1,16 @@
 import ThemeCommand from './theme-command.js'
+import {ensureThemeStore} from './theme-store.js'
 import {describe, vi, expect, test, beforeEach} from 'vitest'
 import {Config, Flags} from '@oclif/core'
 import {AdminSession, ensureAuthenticatedThemes} from '@shopify/cli-kit/node/session'
 import {loadEnvironment} from '@shopify/cli-kit/node/environments'
-import {renderConcurrent} from '@shopify/cli-kit/node/ui'
+import {renderConcurrent, renderConfirmationPrompt, renderError} from '@shopify/cli-kit/node/ui'
 import type {Writable} from 'stream'
 
 vi.mock('@shopify/cli-kit/node/session')
 vi.mock('@shopify/cli-kit/node/environments')
 vi.mock('@shopify/cli-kit/node/ui')
+vi.mock('./theme-store.js')
 
 const CommandConfig = new Config({root: __dirname})
 
@@ -29,10 +31,30 @@ class TestThemeCommand extends ThemeCommand {
 
   static multiEnvironmentsFlags = ['store']
 
-  commandCalls: {flags: any; session: AdminSession; context?: any}[] = []
+  commandCalls: {flags: any; session: AdminSession; multiEnvironment?: boolean; context?: any}[] = []
 
-  async command(flags: any, session: AdminSession, context?: {stdout?: Writable; stderr?: Writable}): Promise<void> {
-    this.commandCalls.push({flags, session, context})
+  async command(
+    flags: any,
+    session: AdminSession,
+    multiEnvironment?: boolean,
+    context?: {stdout?: Writable; stderr?: Writable},
+  ): Promise<void> {
+    this.commandCalls.push({flags, session, multiEnvironment, context})
+
+    if (flags.environment && flags.environment[0] === 'command-error') {
+      throw new Error('Mocking a command error')
+    }
+  }
+}
+
+class TestThemeCommandWithForce extends TestThemeCommand {
+  static flags = {
+    ...TestThemeCommand.flags,
+    force: Flags.boolean({
+      char: 'f',
+      description: 'Skip confirmation',
+      env: 'SHOPIFY_FLAG_FORCE',
+    }),
   }
 }
 
@@ -44,6 +66,7 @@ describe('ThemeCommand', () => {
       token: 'test-token',
       storeFqdn: 'test-store.myshopify.com',
     }
+    vi.mocked(ensureThemeStore).mockReturnValue('test-store.myshopify.com')
     vi.mocked(ensureAuthenticatedThemes).mockResolvedValue(mockSession)
   })
 
@@ -52,7 +75,6 @@ describe('ThemeCommand', () => {
       // Given
       await CommandConfig.load()
       const command = new TestThemeCommand([], CommandConfig)
-
       // When
       await command.run()
 
@@ -125,4 +147,189 @@ describe('ThemeCommand', () => {
       )
     })
   })
+
+  describe('multi environment', () => {
+    test('commands with --force flag should not prompt for confirmation', async () => {
+      // Given
+      const environmentConfig = {store: 'store.myshopify.com'}
+      vi.mocked(loadEnvironment).mockResolvedValue(environmentConfig)
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(true)
+      vi.mocked(renderConcurrent).mockResolvedValue(undefined)
+
+      await CommandConfig.load()
+      const command = new TestThemeCommandWithForce(
+        ['--environment', 'development', '--environment', 'staging', '--force'],
+        CommandConfig,
+      )
+
+      // When
+      await command.run()
+
+      // Then
+      expect(renderConfirmationPrompt).not.toHaveBeenCalled()
+      expect(renderConcurrent).toHaveBeenCalledOnce()
+      expect(renderConcurrent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          processes: expect.arrayContaining([
+            expect.objectContaining({prefix: 'development'}),
+            expect.objectContaining({prefix: 'staging'}),
+          ]),
+          showTimestamps: true,
+        }),
+      )
+    })
+
+    test('commands that do not allow --force flag should not prompt for confirmation', async () => {
+      // Given
+      const environmentConfig = {store: 'store.myshopify.com'}
+      vi.mocked(loadEnvironment).mockResolvedValue(environmentConfig)
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(true)
+      vi.mocked(renderConcurrent).mockResolvedValue(undefined)
+
+      await CommandConfig.load()
+      const command = new TestThemeCommand(['--environment', 'development', '--environment', 'staging'], CommandConfig)
+
+      // When
+      await command.run()
+
+      // Then
+      expect(renderConfirmationPrompt).not.toHaveBeenCalled()
+      expect(renderConcurrent).toHaveBeenCalledOnce()
+    })
+
+    test('commands without --force flag that allow it should prompt for confirmation', async () => {
+      // Given
+      const environmentConfig = {store: 'store.myshopify.com'}
+      vi.mocked(loadEnvironment).mockResolvedValue(environmentConfig)
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(true)
+      vi.mocked(renderConcurrent).mockResolvedValue(undefined)
+
+      await CommandConfig.load()
+      const command = new TestThemeCommandWithForce(
+        ['--environment', 'development', '--environment', 'staging'],
+        CommandConfig,
+      )
+
+      // When
+      await command.run()
+
+      // Then
+      expect(renderConfirmationPrompt).toHaveBeenCalledOnce()
+      expect(renderConfirmationPrompt).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.any(Array),
+          confirmationMessage: 'Yes, proceed',
+          cancellationMessage: 'Cancel',
+        }),
+      )
+      expect(renderConcurrent).toHaveBeenCalledOnce()
+    })
+
+    test('should not execute command if confirmation is cancelled', async () => {
+      // Given
+      const environmentConfig = {store: 'store.myshopify.com'}
+      vi.mocked(loadEnvironment).mockResolvedValue(environmentConfig)
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(false)
+      vi.mocked(renderConcurrent).mockResolvedValue(undefined)
+
+      await CommandConfig.load()
+      const command = new TestThemeCommandWithForce(
+        ['--environment', 'development', '--environment', 'staging'],
+        CommandConfig,
+      )
+
+      // When
+      await command.run()
+
+      // Then
+      expect(renderConfirmationPrompt).toHaveBeenCalledOnce()
+      expect(renderConcurrent).not.toHaveBeenCalled()
+    })
+
+    test('should not execute commands in environments that are missing required flags', async () => {
+      // Given
+      vi.mocked(loadEnvironment)
+        .mockResolvedValueOnce({store: 'store1.myshopify.com'})
+        .mockResolvedValueOnce({})
+        .mockResolvedValueOnce({store: 'store3.myshopify.com'})
+
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(true)
+      vi.mocked(renderConcurrent).mockResolvedValue(undefined)
+
+      await CommandConfig.load()
+      const command = new TestThemeCommand(
+        ['--environment', 'development', '--environment', 'env-missing-store', '--environment', 'production'],
+        CommandConfig,
+      )
+
+      // When
+      await command.run()
+
+      // Then
+      const renderConcurrentProcesses = vi.mocked(renderConcurrent).mock.calls[0]?.[0]?.processes
+      expect(renderConcurrentProcesses).toHaveLength(2)
+      expect(renderConcurrentProcesses?.map((process) => process.prefix)).toEqual(['development', 'production'])
+    })
+
+    test('commands error gracefully and continue with other environments', async () => {
+      // Given
+      vi.mocked(loadEnvironment).mockResolvedValue({store: 'store.myshopify.com'})
+
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(true)
+      vi.mocked(renderConcurrent).mockImplementation(async ({processes}) => {
+        for (const process of processes) {
+          // eslint-disable-next-line no-await-in-loop
+          await process.action({} as Writable, {} as Writable, {} as any)
+        }
+      })
+
+      await CommandConfig.load()
+      const command = new TestThemeCommand(
+        ['--environment', 'command-error', '--environment', 'development', '--environment', 'production'],
+        CommandConfig,
+      )
+
+      // When
+      await command.run()
+
+      // Then
+      const renderConcurrentProcesses = vi.mocked(renderConcurrent).mock.calls[0]?.[0]?.processes
+      expect(renderConcurrentProcesses).toHaveLength(3)
+      expect(renderConcurrentProcesses?.map((process) => process.prefix)).toEqual([
+        'command-error',
+        'development',
+        'production',
+      ])
+    })
+
+    test('error messages contain the environment name', async () => {
+      // Given
+      const environmentConfig = {store: 'store.myshopify.com'}
+      vi.mocked(loadEnvironment).mockResolvedValue(environmentConfig)
+      vi.mocked(renderConfirmationPrompt).mockResolvedValue(true)
+
+      vi.mocked(renderConcurrent).mockImplementation(async ({processes}) => {
+        for (const process of processes) {
+          // eslint-disable-next-line no-await-in-loop
+          await process.action({} as Writable, {} as Writable, {} as any)
+        }
+      })
+
+      await CommandConfig.load()
+      const command = new TestThemeCommand(
+        ['--environment', 'command-error', '--environment', 'development'],
+        CommandConfig,
+      )
+
+      // When
+      await command.run()
+
+      // Then
+      expect(renderError).toHaveBeenCalledWith(
+        expect.objectContaining({
+          body: ['Environment command-error failed: \n\nMocking a command error'],
+        }),
+      )
+    })
+  })
 })