Update theme check command for multi-environment

Previously theme check command could only be run
in a single environment at a time. This commit allows
check to be run in multiple environments in a single
command run

Author: dejmedus

.changeset/seven-goats-agree.md

@@ -0,0 +1,5 @@
+---
+'@shopify/theme': minor
+---
+
+Allow theme check command to be called with multiple environments

packages/cli/oclif.manifest.json

@@ -5095,6 +5095,9 @@
       "hiddenAliases": [
       ],
       "id": "theme:check",
+      "multiEnvironmentsFlags": [
+        "path"
+      ],
       "pluginAlias": "@shopify/cli",
       "pluginName": "@shopify/cli",
       "pluginType": "core",

packages/theme/src/cli/commands/theme/check.ts

@@ -2,17 +2,17 @@ import {themeFlags} from '../../flags.js'
 import {
   formatOffensesJson,
   formatSummary,
-  handleExit,
   initConfig,
   outputActiveChecks,
   outputActiveConfig,
   performAutoFixes,
   renderOffensesText,
   sortOffenses,
   isExtendedWriteStream,
+  handleExit,
   type FailLevel,
 } from '../../services/check.js'
-import ThemeCommand from '../../utilities/theme-command.js'
+import ThemeCommand, {RequiredFlags} from '../../utilities/theme-command.js'
 import {Flags} from '@oclif/core'
 import {globalFlags} from '@shopify/cli-kit/node/cli'
 import {outputResult, outputDebug} from '@shopify/cli-kit/node/output'
@@ -21,7 +21,10 @@ import {themeCheckRun, LegacyIdentifiers} from '@shopify/theme-check-node'
 import {findPathUp} from '@shopify/cli-kit/node/fs'
 import {moduleDirectory, joinPath} from '@shopify/cli-kit/node/path'
 import {getPackageVersion} from '@shopify/cli-kit/node/node-package-manager'
+import {InferredFlags} from '@oclif/core/interfaces'
+import {AdminSession} from '@shopify/cli-kit/node/session'
 
+type CheckFlags = InferredFlags<typeof Check.flags>
 export default class Check extends ThemeCommand {
   static summary = 'Validate the theme.'
 
@@ -86,11 +89,12 @@ export default class Check extends ThemeCommand {
     environment: themeFlags.environment,
   }
 
-  async run(): Promise<void> {
-    const {flags} = await this.parse(Check)
+  static multiEnvironmentsFlags: RequiredFlags = ['path']
 
+  async command(flags: CheckFlags, _session: AdminSession, multiEnvironment: boolean): Promise<void> {
     // Its not clear to typescript that path will always be defined
     const path = flags.path
+    const environment = flags.environment?.[0]
     // To support backwards compatibility for legacy configs
     const isLegacyConfig = flags.config?.startsWith(':') && LegacyIdentifiers.has(flags.config.slice(1))
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -121,30 +125,32 @@ export default class Check extends ThemeCommand {
     }
 
     if (flags.print) {
-      await outputActiveConfig(path, config)
+      await outputActiveConfig(path, config, environment)
 
       // --print should not trigger full theme check operation
       return
     }
 
     if (flags.list) {
-      await outputActiveChecks(path, config)
+      await outputActiveChecks(path, config, environment)
 
       // --list should not trigger full theme check operation
       return
     }
 
-    const {offenses, theme} = await runThemeCheck(path, flags.output, config)
+    const {offenses, theme} = await runThemeCheck(path, flags.output, config, environment)
 
     if (flags['auto-correct']) {
       await performAutoFixes(theme, offenses)
     }
 
-    return handleExit(offenses, flags['fail-level'] as FailLevel)
+    if (!multiEnvironment) {
+      return handleExit(offenses, flags['fail-level'] as FailLevel)
+    }
   }
 }
 
-export async function runThemeCheck(path: string, outputFormat: string, config?: string) {
+export async function runThemeCheck(path: string, outputFormat: string, config?: string, environment?: string) {
   const {offenses, theme} = await themeCheckRun(path, config, (message) => {
     if (process.env.SHOPIFY_TMP_FLAG_DEBUG) {
       outputDebug(message)
@@ -154,13 +160,13 @@ export async function runThemeCheck(path: string, outputFormat: string, config?:
   const offensesByFile = sortOffenses(offenses)
 
   if (outputFormat === 'text') {
-    renderOffensesText(offensesByFile, path)
+    renderOffensesText(offensesByFile, path, environment)
 
     // Use renderSuccess when theres no offenses
     const render = offenses.length ? renderInfo : renderSuccess
 
     render({
-      headline: 'Theme Check Summary.',
+      headline: environment ? `[${environment}] Theme Check Summary.` : 'Theme Check Summary.',
       body: formatSummary(offenses, offensesByFile, theme),
     })
   }
@@ -181,7 +187,7 @@ export async function runThemeCheck(path: string, outputFormat: string, config?:
       stdout._handle.setBlocking(true)
     }
 
-    outputResult(JSON.stringify(formatOffensesJson(offensesByFile)))
+    outputResult(JSON.stringify(formatOffensesJson(offensesByFile, environment)))
   }
 
   return {offenses, theme}

packages/theme/src/cli/services/check.ts

@@ -194,7 +194,7 @@ export function formatSummary(offenses: Offense[], offensesByFile: OffenseMap, t
   return summary
 }
 
-export function renderOffensesText(offensesByFile: OffenseMap, themeRootPath: string) {
+export function renderOffensesText(offensesByFile: OffenseMap, themeRootPath: string, environment?: string) {
   const fileNames = Object.keys(offensesByFile).sort()
 
   fileNames.forEach((filePath) => {
@@ -203,13 +203,13 @@ export function renderOffensesText(offensesByFile: OffenseMap, themeRootPath: st
     const headlineFilePath = filePath.replace(themeRootPath, '').slice(1)
 
     renderInfo({
-      headline: headlineFilePath,
+      headline: environment ? `[${environment}] ${headlineFilePath}` : headlineFilePath,
       body: formatOffenses(offensesByFile[filePath]!),
     })
   })
 }
 
-export function formatOffensesJson(offensesByFile: OffenseMap): TransformedOffenseMap[] {
+export function formatOffensesJson(offensesByFile: OffenseMap, environment?: string): TransformedOffenseMap[] {
   return Object.entries(offensesByFile).map(([path, offenses]) => {
     const transformedOffenses = offenses.map((offense: Offense) => {
       return {
@@ -226,6 +226,7 @@ export function formatOffensesJson(offensesByFile: OffenseMap): TransformedOffen
     const counts = countOffenseTypes(offenses)
 
     return {
+      environment,
       path,
       offenses: transformedOffenses,
       errorCount: counts[Severity.ERROR] ?? 0,
@@ -288,7 +289,7 @@ export async function performAutoFixes(sourceCodes: Theme, offenses: Offense[])
   await autofix(sourceCodes, offenses, saveToDiskFixApplicator)
 }
 
-export async function outputActiveConfig(themeRoot: string, configPath?: string) {
+export async function outputActiveConfig(themeRoot: string, configPath?: string, environment?: string) {
   const {ignore, settings, rootUri} = await loadConfig(configPath, themeRoot)
 
   const config = {
@@ -304,10 +305,11 @@ export async function outputActiveConfig(themeRoot: string, configPath?: string)
     // Dump out the active settings for all checks.
     ...settings,
   }
-  outputResult(YAML.stringify(config))
+  const output = environment ? {[environment]: config} : config
+  outputResult(YAML.stringify(output))
 }
 
-export async function outputActiveChecks(root: string, configPath?: string) {
+export async function outputActiveChecks(root: string, configPath?: string, environment?: string) {
   const {settings, ignore, checks} = await loadConfig(configPath, root)
   // Depending on how the configs were merged during loadConfig, there may be
   // duplicate patterns to ignore. We can clean them before outputting.
@@ -343,7 +345,8 @@ export async function outputActiveChecks(root: string, configPath?: string) {
     return acc
   }, {})
 
-  outputResult(YAML.stringify(checksList))
+  const output = environment ? {[environment]: checksList} : checksList
+  outputResult(YAML.stringify(output))
 }
 
 interface ExtendedWriteStream extends NodeJS.WriteStream {