Merge pull request #4429 from Shopify/ms.update-function-runner-to-us-ds

[ShopifyVM] Update-function runner to use dynamic scaling

.changeset/sixty-mangos-beam.md

@@ -0,0 +1,5 @@
+---
+'@shopify/app': minor
+---
+
+Bumps function-runner version to include details on dynamic resource limits.

packages/app/src/cli/commands/app/function/run.ts

@@ -1,4 +1,4 @@
-import {functionFlags, inFunctionContext} from '../../../services/function/common.js'
+import {functionFlags, inFunctionContext, getOrGenerateSchemaPath} from '../../../services/function/common.js'
 import {runFunction} from '../../../services/function/runner.js'
 import {appFlags} from '../../../flags.js'
 import Command from '@shopify/cli-kit/node/base-command'
@@ -44,7 +44,7 @@ export default class FunctionRun extends Command {
     await inFunctionContext({
       path: flags.path,
       userProvidedConfigName: flags.config,
-      callback: async (_app, ourFunction) => {
+      callback: async (app, ourFunction) => {
         let functionExport = DEFAULT_FUNCTION_EXPORT
 
         if (flags.export !== undefined) {
@@ -78,12 +78,18 @@ export default class FunctionRun extends Command {
           )
         }
 
+        const inputQueryPath = ourFunction?.configuration.targeting?.[0]?.input_query
+        const queryPath = inputQueryPath && `${ourFunction?.directory}/${inputQueryPath}`
+        const schemaPath = await getOrGenerateSchemaPath(ourFunction, app)
+
         await runFunction({
           functionExtension: ourFunction,
           json: flags.json,
           inputPath: flags.input,
           export: functionExport,
           stdin: 'inherit',
+          schemaPath,
+          queryPath,
         })
       },
     })

packages/app/src/cli/services/function/binaries.ts

@@ -8,7 +8,7 @@ import * as gzip from 'node:zlib'
 import {fileURLToPath} from 'node:url'
 
 const JAVY_VERSION = 'v3.0.1'
-const FUNCTION_RUNNER_VERSION = 'v6.0.0'
+const FUNCTION_RUNNER_VERSION = 'v6.2.0'
 
 // The logic for determining the download URL and what to do with the response stream is _coincidentally_ the same for
 // Javy and function-runner for now. Those methods may not continue to have the same logic in the future. If they

packages/app/src/cli/services/function/common.test.ts

@@ -1,16 +1,21 @@
-import {inFunctionContext} from './common.js'
+import {getOrGenerateSchemaPath, inFunctionContext} from './common.js'
 import {loadApp} from '../../models/app/loader.js'
 import {testApp, testFunctionExtension} from '../../models/app/app.test-data.js'
 import {AppInterface} 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'
 import {describe, vi, expect, beforeEach, test} from 'vitest'
 import {renderAutocompletePrompt, renderFatalError} from '@shopify/cli-kit/node/ui'
 import {joinPath} from '@shopify/cli-kit/node/path'
 import {isTerminalInteractive} from '@shopify/cli-kit/node/context/local'
+import {fileExists} from '@shopify/cli-kit/node/fs'
 
 vi.mock('../../models/app/loader.js')
 vi.mock('@shopify/cli-kit/node/ui')
 vi.mock('@shopify/cli-kit/node/context/local')
+vi.mock('@shopify/cli-kit/node/fs')
+vi.mock('../generate-schema.js')
 
 let app: AppInterface
 let ourFunction: ExtensionInstance
@@ -73,6 +78,49 @@ describe('ensure we are within a function context', () => {
       }),
     ).rejects.toThrowError()
 
+    // Then
     expect(ranCallback).toBe(false)
   })
 })
+
+describe('getOrGenerateSchemaPath', () => {
+  let extension: ExtensionInstance<FunctionConfigType>
+  let app: AppInterface
+
+  beforeEach(() => {
+    extension = {
+      directory: '/path/to/function',
+      configuration: {},
+    } as ExtensionInstance<FunctionConfigType>
+
+    app = {} as AppInterface
+  })
+
+  test('returns the path if the schema file exists', async () => {
+    // Given
+    const expectedPath = joinPath(extension.directory, 'schema.graphql')
+    vi.mocked(fileExists).mockResolvedValue(true)
+
+    // When
+    const result = await getOrGenerateSchemaPath(extension, app)
+
+    // Then
+    expect(result).toBe(expectedPath)
+    expect(fileExists).toHaveBeenCalledWith(expectedPath)
+  })
+
+  test('generates the schema file if it does not exist', async () => {
+    // Given
+    const expectedPath = joinPath(extension.directory, 'schema.graphql')
+    vi.mocked(fileExists).mockResolvedValue(false)
+    vi.mocked(generateSchemaService).mockResolvedValueOnce()
+    vi.mocked(fileExists).mockResolvedValueOnce(true)
+
+    // When
+    const result = await getOrGenerateSchemaPath(extension, app)
+
+    // Then
+    expect(result).toBe(expectedPath)
+    expect(fileExists).toHaveBeenCalledWith(expectedPath)
+  })
+})

packages/app/src/cli/services/function/common.ts

@@ -3,11 +3,13 @@ import {loadApp} from '../../models/app/loader.js'
 import {loadLocalExtensionsSpecifications} from '../../models/extensions/load-specifications.js'
 import {ExtensionInstance} from '../../models/extensions/extension-instance.js'
 import {FunctionConfigType} from '../../models/extensions/specifications/function.js'
-import {resolvePath, cwd} from '@shopify/cli-kit/node/path'
+import {generateSchemaService} from '../generate-schema.js'
+import {resolvePath, cwd, joinPath} from '@shopify/cli-kit/node/path'
 import {AbortError} from '@shopify/cli-kit/node/error'
 import {Flags} from '@oclif/core'
 import {isTerminalInteractive} from '@shopify/cli-kit/node/context/local'
 import {renderAutocompletePrompt} from '@shopify/cli-kit/node/ui'
+import {fileExists} from '@shopify/cli-kit/node/fs'
 
 export const functionFlags = {
   path: Flags.string({
@@ -50,3 +52,22 @@ export async function inFunctionContext({
     throw new AbortError('Run this command from a function directory or use `--path` to specify a function directory.')
   }
 }
+
+export async function getOrGenerateSchemaPath(
+  extension: ExtensionInstance<FunctionConfigType>,
+  app: AppInterface,
+): Promise<string | undefined> {
+  const path = joinPath(extension.directory, 'schema.graphql')
+  if (await fileExists(path)) {
+    return path
+  }
+
+  await generateSchemaService({
+    app,
+    extension,
+    stdout: false,
+    path: extension.directory,
+  })
+
+  return (await fileExists(path)) ? path : undefined
+}

packages/app/src/cli/services/function/runner.test.ts

@@ -39,6 +39,8 @@ describe('runFunction', () => {
       stdin: new Readable(),
       stdout: new Writable(),
       stderr: new Writable(),
+      schemaPath: 'schemaPath',
+      queryPath: 'src/queryPath',
     }
 
     // When
@@ -47,7 +49,19 @@ describe('runFunction', () => {
     // Then
     expect(exec).toHaveBeenCalledWith(
       functionRunnerBinary().path,
-      ['-f', functionExtension.outputPath, '--input', options.inputPath, '--export', options.export, '--json'],
+      [
+        '-f',
+        functionExtension.outputPath,
+        '--input',
+        options.inputPath,
+        '--export',
+        options.export,
+        '--json',
+        '--schema-path',
+        options.schemaPath,
+        '--query-path',
+        options.queryPath,
+      ],
       {
         cwd: functionExtension.directory,
         stdin: options.stdin,

packages/app/src/cli/services/function/runner.ts

@@ -10,6 +10,8 @@ interface FunctionRunnerOptions {
   inputPath?: string
   export?: string
   json?: boolean
+  schemaPath?: string
+  queryPath?: string
   stdin?: Readable | 'inherit'
   stdout?: Writable | 'inherit'
   stderr?: Writable | 'inherit'
@@ -29,6 +31,10 @@ export async function runFunction(options: FunctionRunnerOptions) {
   if (options.json) {
     args.push('--json')
   }
+  if (options.schemaPath && options.queryPath) {
+    args.push('--schema-path', options.schemaPath)
+    args.push('--query-path', options.queryPath)
+  }
 
   return exec(functionRunner.path, ['-f', options.functionExtension.outputPath, ...args], {
     cwd: options.functionExtension.directory,