Add stdin support for shopify app execute

Author: ericlee878

packages/app/src/cli/flags.ts

@@ -38,9 +38,9 @@ export const appFlags = {
 export const bulkOperationFlags = {
   query: Flags.string({
     char: 'q',
-    description: 'The GraphQL query or mutation to run as a bulk operation.',
+    description: 'The GraphQL query or mutation to run as a bulk operation. If omitted, reads from standard input.',
     env: 'SHOPIFY_FLAG_QUERY',
-    required: true,
+    required: false,
   }),
   variables: Flags.string({
     char: 'v',

packages/app/src/cli/services/bulk-operations/execute-bulk-operation.test.ts

@@ -5,13 +5,15 @@ import {AppLinkedInterface} from '../../models/app/app.js'
 import {OrganizationApp} from '../../models/organization.js'
 import {renderSuccess, renderWarning} from '@shopify/cli-kit/node/ui'
 import {ensureAuthenticatedAdminAsApp} from '@shopify/cli-kit/node/session'
+import {readStdin} from '@shopify/cli-kit/node/system'
 import {inTemporaryDirectory, writeFile} from '@shopify/cli-kit/node/fs'
 import {joinPath} from '@shopify/cli-kit/node/path'
 import {describe, test, expect, vi, beforeEach} from 'vitest'
 
 vi.mock('./run-query.js')
 vi.mock('./run-mutation.js')
 vi.mock('@shopify/cli-kit/node/ui')
+vi.mock('@shopify/cli-kit/node/system')
 vi.mock('@shopify/cli-kit/node/session', async () => {
   const actual = await vi.importActual('@shopify/cli-kit/node/session')
   return {
@@ -335,4 +337,67 @@ describe('executeBulkOperation', () => {
       expect(runBulkOperationMutation).not.toHaveBeenCalled()
     })
   })
+
+  test('reads query from stdin when query flag is not provided', async () => {
+    const stdinQuery = '{ products { edges { node { id } } } }'
+    vi.mocked(readStdin).mockResolvedValue(stdinQuery)
+
+    const mockResponse = {
+      bulkOperation: successfulBulkOperation,
+      userErrors: [],
+    }
+    vi.mocked(runBulkOperationQuery).mockResolvedValue(mockResponse as any)
+
+    await executeBulkOperation({
+      app: mockApp,
+      remoteApp: mockRemoteApp,
+      storeFqdn,
+    })
+
+    expect(readStdin).toHaveBeenCalled()
+    expect(runBulkOperationQuery).toHaveBeenCalledWith({
+      adminSession: mockAdminSession,
+      query: stdinQuery,
+    })
+  })
+
+  test('prefers query flag over stdin when both are available', async () => {
+    const flagQuery = 'query { orders { edges { node { id } } } }'
+    const stdinQuery = '{ products { edges { node { id } } } }'
+    vi.mocked(readStdin).mockResolvedValue(stdinQuery)
+
+    const mockResponse = {
+      bulkOperation: successfulBulkOperation,
+      userErrors: [],
+    }
+    vi.mocked(runBulkOperationQuery).mockResolvedValue(mockResponse as any)
+
+    await executeBulkOperation({
+      app: mockApp,
+      remoteApp: mockRemoteApp,
+      storeFqdn,
+      query: flagQuery,
+    })
+
+    expect(readStdin).not.toHaveBeenCalled()
+    expect(runBulkOperationQuery).toHaveBeenCalledWith({
+      adminSession: mockAdminSession,
+      query: flagQuery,
+    })
+  })
+
+  test('throws error when no query is provided and stdin is empty', async () => {
+    vi.mocked(readStdin).mockResolvedValue(undefined)
+
+    await expect(
+      executeBulkOperation({
+        app: mockApp,
+        remoteApp: mockRemoteApp,
+        storeFqdn,
+      }),
+    ).rejects.toThrow('No query provided')
+
+    expect(runBulkOperationQuery).not.toHaveBeenCalled()
+    expect(runBulkOperationMutation).not.toHaveBeenCalled()
+  })
 })

packages/app/src/cli/services/bulk-operations/execute-bulk-operation.ts

@@ -6,18 +6,39 @@ import {renderSuccess, renderInfo, renderWarning} from '@shopify/cli-kit/node/ui
 import {outputContent, outputToken} from '@shopify/cli-kit/node/output'
 import {ensureAuthenticatedAdminAsApp} from '@shopify/cli-kit/node/session'
 import {AbortError} from '@shopify/cli-kit/node/error'
+import {readStdin} from '@shopify/cli-kit/node/system'
 import {parse} from 'graphql'
 import {readFile, fileExists} from '@shopify/cli-kit/node/fs'
 
 interface ExecuteBulkOperationInput {
   app: AppLinkedInterface
   remoteApp: OrganizationApp
   storeFqdn: string
-  query: string
+  query?: string
   variables?: string[]
   variableFile?: string
 }
 
+/**
+ * Resolves the query from the provided flag or stdin.
+ * Follows the same pattern as parseVariablesToJsonl for consistency.
+ */
+async function resolveQuery(query?: string): Promise<string> {
+  if (query) {
+    return query
+  }
+
+  const stdinContent = await readStdin()
+  if (stdinContent) {
+    return stdinContent
+  }
+
+  throw new AbortError(
+    'No query provided. Use the --query flag or pipe input via stdin.',
+    'Example: echo "query { ... }" | shopify app execute',
+  )
+}
+
 async function parseVariablesToJsonl(variables?: string[], variableFile?: string): Promise<string | undefined> {
   if (variables) {
     return variables.join('\n')
@@ -36,7 +57,9 @@ async function parseVariablesToJsonl(variables?: string[], variableFile?: string
 }
 
 export async function executeBulkOperation(input: ExecuteBulkOperationInput): Promise<void> {
-  const {app, remoteApp, storeFqdn, query, variables, variableFile} = input
+  const {app, remoteApp, storeFqdn, variables, variableFile} = input
+
+  const query = await resolveQuery(input.query)
 
   renderInfo({
     headline: 'Starting bulk operation.',

packages/cli-kit/src/public/node/system.test.ts

@@ -2,6 +2,7 @@ import * as system from './system.js'
 import {execa} from 'execa'
 import {describe, expect, test, vi} from 'vitest'
 import which from 'which'
+import {Readable} from 'stream'
 
 vi.mock('which')
 vi.mock('execa')
@@ -30,3 +31,52 @@ describe('captureOutput', () => {
     await expect(got).rejects.toThrowError('Skipped run of unsecure binary command found in the current directory.')
   })
 })
+
+describe('isStdinPiped', () => {
+  test('returns true when stdin is piped', () => {
+    // Given
+    Object.defineProperty(process.stdin, 'isTTY', {value: false, configurable: true})
+
+    // When
+    const got = system.isStdinPiped()
+
+    // Then
+    expect(got).toBe(true)
+  })
+
+  test('returns false when stdin is interactive', () => {
+    // Given
+    Object.defineProperty(process.stdin, 'isTTY', {value: true, configurable: true})
+
+    // When
+    const got = system.isStdinPiped()
+
+    // Then
+    expect(got).toBe(false)
+  })
+})
+
+describe('readStdin', () => {
+  test('returns undefined when stdin is not piped', async () => {
+    // Given
+    Object.defineProperty(process.stdin, 'isTTY', {value: true, configurable: true})
+
+    // When
+    const got = await system.readStdin()
+
+    // Then
+    expect(got).toBeUndefined()
+  })
+
+  test('returns trimmed content when stdin is piped', async () => {
+    // Given
+    const mockStdin = Object.assign(Readable.from(['hello world']), {isTTY: false})
+    vi.spyOn(process, 'stdin', 'get').mockReturnValue(mockStdin as unknown as typeof process.stdin)
+
+    // When
+    const got = await system.readStdin()
+
+    // Then
+    expect(got).toBe('hello world')
+  })
+})

packages/cli-kit/src/public/node/system.ts

@@ -200,3 +200,36 @@ export async function isWsl(): Promise<boolean> {
   const wsl = await import('is-wsl')
   return wsl.default
 }
+
+/**
+ * Check if stdin has piped data available (not a TTY).
+ * This is useful for detecting when a command is receiving input via piping.
+ *
+ * @returns True if stdin is being piped, false if it's interactive.
+ */
+export function isStdinPiped(): boolean {
+  return !process.stdin.isTTY
+}
+
+/**
+ * Reads all data from stdin and returns it as a string.
+ * This is useful for commands that accept input via piping.
+ *
+ * @example
+ * // Usage: echo "your query" | shopify app execute
+ * const query = await readStdin()
+ *
+ * @returns A promise that resolves with the stdin content, or undefined if stdin is a TTY.
+ */
+export async function readStdin(): Promise<string | undefined> {
+  if (!isStdinPiped()) {
+    return undefined
+  }
+
+  let data = ''
+  process.stdin.setEncoding('utf8')
+  for await (const chunk of process.stdin) {
+    data += String(chunk)
+  }
+  return data.trim()
+}