Merge pull request #5980 from Shopify/skip-auth-for-function-build

gonzaloriestra · web-flow · commit 867e7e8e4936 · 2025-06-20T16:46:11.000Z
Do not require authentication for app function build
diff --git a/packages/app/src/cli/commands/app/function/build.ts b/packages/app/src/cli/commands/app/function/build.ts
@@ -1,11 +1,12 @@
-import {inFunctionContext, functionFlags} from '../../../services/function/common.js'
+import {chooseFunction, functionFlags} from '../../../services/function/common.js'
 import {buildFunctionExtension} from '../../../services/build/extension.js'
 import {appFlags} from '../../../flags.js'
-import AppLinkedCommand, {AppLinkedCommandOutput} from '../../../utilities/app-linked-command.js'
+import AppUnlinkedCommand, {AppUnlinkedCommandOutput} from '../../../utilities/app-unlinked-command.js'
+import {localAppContext} from '../../../services/app-context.js'
 import {globalFlags} from '@shopify/cli-kit/node/cli'
 import {renderSuccess} from '@shopify/cli-kit/node/ui'
 
-export default class FunctionBuild extends AppLinkedCommand {
+export default class FunctionBuild extends AppUnlinkedCommand {
   static summary = 'Compile a function to wasm.'
 
   static descriptionWithMarkdown = `Compiles the function in your current directory to WebAssembly (Wasm) for testing purposes.`
@@ -18,26 +19,25 @@ export default class FunctionBuild extends AppLinkedCommand {
     ...functionFlags,
   }
 
-  public async run(): Promise<AppLinkedCommandOutput> {
+  public async run(): Promise<AppUnlinkedCommandOutput> {
     const {flags} = await this.parse(FunctionBuild)
 
-    const app = await inFunctionContext({
-      path: flags.path,
+    const app = await localAppContext({
+      directory: flags.path,
       userProvidedConfigName: flags.config,
-      apiKey: flags['client-id'],
-      reset: flags.reset,
-      callback: async (app, _, ourFunction) => {
-        await buildFunctionExtension(ourFunction, {
-          app,
-          stdout: process.stdout,
-          stderr: process.stderr,
-          useTasks: true,
-          environment: 'production',
-        })
-        renderSuccess({headline: 'Function built successfully.'})
-        return app
-      },
     })
+
+    const ourFunction = await chooseFunction(app, flags.path)
+
+    await buildFunctionExtension(ourFunction, {
+      app,
+      stdout: process.stdout,
+      stderr: process.stderr,
+      useTasks: true,
+      environment: 'production',
+    })
+    renderSuccess({headline: 'Function built successfully.'})
+
     return {app}
   }
 }
diff --git a/packages/app/src/cli/services/function/common.test.ts b/packages/app/src/cli/services/function/common.test.ts
@@ -1,4 +1,4 @@
-import {getOrGenerateSchemaPath, inFunctionContext} from './common.js'
+import {getOrGenerateSchemaPath, inFunctionContext, chooseFunction} from './common.js'
 import {
   testAppLinked,
   testDeveloperPlatformClient,
@@ -42,59 +42,51 @@ beforeEach(async () => {
   vi.mocked(isTerminalInteractive).mockReturnValue(true)
 })
 
-describe('ensure we are within a function context', () => {
-  test('runs callback when we are inside a function directory', async () => {
+describe('inFunctionContext integration', () => {
+  test('passes correct parameters to callback when function is found', async () => {
     // Given
-    let ranCallback = false
+    const callback = vi.fn().mockResolvedValue(app)
 
     // When
     await inFunctionContext({
       path: joinPath(app.directory, 'extensions/my-function'),
-      callback: async (_app, _fun) => {
-        ranCallback = true
-        return _app
-      },
+      callback,
     })
 
     // Then
-    expect(ranCallback).toBe(true)
-    expect(renderFatalError).not.toHaveBeenCalled()
+    expect(callback).toHaveBeenCalledWith(
+      app,
+      // developerPlatformClient
+      expect.any(Object),
+      ourFunction,
+      // orgId
+      expect.any(String),
+    )
   })
 
-  test('displays function prompt when we are not inside a function directory', async () => {
+  test('calls linkedAppContext with correct parameters', async () => {
     // Given
-    const callback = vi.fn()
+    const callback = vi.fn().mockResolvedValue(app)
+    const path = 'some/path'
+    const apiKey = 'test-api-key'
+    const userProvidedConfigName = 'test-config'
 
     // When
     await inFunctionContext({
-      path: 'random/dir',
+      path,
+      apiKey,
+      userProvidedConfigName,
+      reset: true,
       callback,
     })
 
     // Then
-    expect(callback).toHaveBeenCalledOnce()
-    expect(renderAutocompletePrompt).toHaveBeenCalledOnce()
-    expect(renderFatalError).not.toHaveBeenCalled()
-  })
-
-  test('displays an error when terminal is not interactive and we are not inside a function directory', async () => {
-    // Given
-    let ranCallback = false
-    vi.mocked(isTerminalInteractive).mockReturnValue(false)
-
-    // When
-    await expect(
-      inFunctionContext({
-        path: 'random/dir',
-        callback: async (_app, _fun) => {
-          ranCallback = true
-          return _app
-        },
-      }),
-    ).rejects.toThrowError()
-
-    // Then
-    expect(ranCallback).toBe(false)
+    expect(linkedAppContext).toHaveBeenCalledWith({
+      directory: path,
+      clientId: apiKey,
+      forceRelink: true,
+      userProvidedConfigName,
+    })
   })
 })
 
@@ -140,3 +132,117 @@ describe('getOrGenerateSchemaPath', () => {
     expect(fileExists).toHaveBeenCalledWith(expectedPath)
   })
 })
+
+describe('chooseFunction', () => {
+  let app: AppLinkedInterface
+  let functionExtension1: ExtensionInstance
+  let functionExtension2: ExtensionInstance
+  let nonFunctionExtension: ExtensionInstance
+
+  beforeEach(async () => {
+    functionExtension1 = await testFunctionExtension({
+      dir: '/path/to/app/extensions/function-1',
+      config: {
+        name: 'function-1',
+        type: 'product_discounts',
+        description: 'Test function 1',
+        build: {
+          command: 'echo "hello world"',
+          watch: ['src/**/*.rs'],
+          wasm_opt: true,
+        },
+        api_version: '2022-07',
+        configuration_ui: true,
+      },
+    })
+
+    functionExtension2 = await testFunctionExtension({
+      dir: '/path/to/app/extensions/function-2',
+      config: {
+        name: 'function-2',
+        type: 'product_discounts',
+        description: 'Test function 2',
+        build: {
+          command: 'echo "hello world"',
+          watch: ['src/**/*.rs'],
+          wasm_opt: true,
+        },
+        api_version: '2022-07',
+        configuration_ui: true,
+      },
+    })
+
+    nonFunctionExtension = {
+      directory: '/path/to/app/extensions/theme',
+      isFunctionExtension: false,
+      handle: 'theme-extension',
+    } as ExtensionInstance
+  })
+
+  test('returns the function when path matches a function directory', async () => {
+    // Given
+    app = testAppLinked({allExtensions: [functionExtension1, functionExtension2, nonFunctionExtension]})
+
+    // When
+    const result = await chooseFunction(app, '/path/to/app/extensions/function-1')
+
+    // Then
+    expect(result).toBe(functionExtension1)
+    expect(renderAutocompletePrompt).not.toHaveBeenCalled()
+  })
+
+  test('returns the only function when app has single function and path does not match', async () => {
+    // Given
+    app = testAppLinked({allExtensions: [functionExtension1, nonFunctionExtension]})
+
+    // When
+    const result = await chooseFunction(app, '/some/other/path')
+
+    // Then
+    expect(result).toBe(functionExtension1)
+    expect(renderAutocompletePrompt).not.toHaveBeenCalled()
+  })
+
+  test('prompts user to select function when multiple functions exist and path does not match', async () => {
+    // Given
+    app = testAppLinked({allExtensions: [functionExtension1, functionExtension2, nonFunctionExtension]})
+    vi.mocked(isTerminalInteractive).mockReturnValue(true)
+    vi.mocked(renderAutocompletePrompt).mockResolvedValue(functionExtension2)
+
+    // When
+    const result = await chooseFunction(app, '/some/other/path')
+
+    // Then
+    expect(result).toBe(functionExtension2)
+    expect(renderAutocompletePrompt).toHaveBeenCalledWith({
+      message: 'Which function?',
+      choices: [
+        {label: functionExtension1.handle, value: functionExtension1},
+        {label: functionExtension2.handle, value: functionExtension2},
+      ],
+    })
+  })
+
+  test('throws error when terminal is not interactive and cannot determine function', async () => {
+    // Given
+    app = testAppLinked({allExtensions: [functionExtension1, functionExtension2]})
+    vi.mocked(isTerminalInteractive).mockReturnValue(false)
+
+    // When/Then
+    await expect(chooseFunction(app, '/some/other/path')).rejects.toThrowError(
+      'Run this command from a function directory or use `--path` to specify a function directory.',
+    )
+    expect(renderAutocompletePrompt).not.toHaveBeenCalled()
+  })
+
+  test('filters out non-function extensions', async () => {
+    // Given
+    app = testAppLinked({allExtensions: [nonFunctionExtension]})
+    vi.mocked(isTerminalInteractive).mockReturnValue(false)
+
+    // When/Then
+    await expect(chooseFunction(app, '/some/path')).rejects.toThrowError(
+      'Run this command from a function directory or use `--path` to specify a function directory.',
+    )
+  })
+})
diff --git a/packages/app/src/cli/services/function/common.ts b/packages/app/src/cli/services/function/common.ts
@@ -1,4 +1,4 @@
-import {AppLinkedInterface} from '../../models/app/app.js'
+import {AppInterface, AppLinkedInterface} from '../../models/app/app.js'
 import {ExtensionInstance} from '../../models/extensions/extension-instance.js'
 import {FunctionConfigType} from '../../models/extensions/specifications/function.js'
 import {generateSchemaService} from '../generate-schema.js'
@@ -47,23 +47,28 @@ export async function inFunctionContext({
     userProvidedConfigName,
   })
 
+  const ourFunction = await chooseFunction(app, path)
+  return callback(app, developerPlatformClient, ourFunction, organization.id)
+}
+
+export async function chooseFunction(app: AppInterface, path: string): Promise<ExtensionInstance<FunctionConfigType>> {
   const allFunctions = app.allExtensions.filter(
     (ext) => ext.isFunctionExtension,
   ) as ExtensionInstance<FunctionConfigType>[]
   const ourFunction = allFunctions.find((fun) => fun.directory === path)
+  if (ourFunction) return ourFunction
+
+  if (allFunctions.length === 1 && allFunctions[0]) return allFunctions[0]
 
-  if (ourFunction) {
-    return callback(app, developerPlatformClient, ourFunction, organization.id)
-  } else if (isTerminalInteractive()) {
+  if (isTerminalInteractive()) {
     const selectedFunction = await renderAutocompletePrompt({
       message: 'Which function?',
       choices: allFunctions.map((shopifyFunction) => ({label: shopifyFunction.handle, value: shopifyFunction})),
     })
-
-    return callback(app, developerPlatformClient, selectedFunction, organization.id)
-  } else {
-    throw new AbortError('Run this command from a function directory or use `--path` to specify a function directory.')
+    return selectedFunction
   }
+
+  throw new AbortError('Run this command from a function directory or use `--path` to specify a function directory.')
 }
 
 export async function getOrGenerateSchemaPath(
