add ability to invoke functionRunner directly

Author: lopert

src/methods/run-function.ts

@@ -5,6 +5,7 @@
 import { spawn } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import fs from 'fs';
 
 /**
  * Interface for the run function result
@@ -48,7 +49,7 @@ export async function runFunction(
       functionName = path.basename(functionDir);
     }
 
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       const shopifyProcess = spawn('shopify', [
         'app', 'function', 'run',
         '--export', exportName,
@@ -130,3 +131,143 @@ export async function runFunction(
   }
 }
 
+/**
+ * Run a function by calling function-runner directly (bypassing Shopify CLI)
+ * @param {String} exportName - The function export name
+ * @param {String} input - The input data
+ * @param {String} [functionPath] - Optional path to the function directory
+ * @param {String} [wasmPath] - Optional direct path to the WASM file
+ * @returns {Object} The function run result
+ */
+export async function runFunctionWithRunnerDirectly(
+  exportName: string,
+  input: Record<string, any>,
+  functionPath?: string,
+  wasmPath?: string
+): Promise<RunFunctionResult> {
+  try {
+    const inputJson = JSON.stringify(input);
+
+    let functionDir, functionName;
+
+    if (functionPath !== undefined && functionPath !== null) {
+      // Use provided function path
+      functionDir = path.resolve(functionPath);
+      functionName = path.basename(functionDir);
+    } else {
+      // Calculate paths correctly for when used as a dependency:
+      // __dirname = /path/to/function/tests/node_modules/function-testing-helpers/src/methods
+      // Go up 5 levels to get to function directory: ../../../../../ = /path/to/function
+      functionDir = path.dirname(path.dirname(path.dirname(path.dirname(path.dirname(__dirname)))));
+      functionName = path.basename(functionDir);
+    }
+
+    // Find WASM file - use provided path or search common locations
+    let resolvedWasmPath: string | null = null;
+
+    if (wasmPath) {
+      // Use user-provided WASM path
+      resolvedWasmPath = path.resolve(wasmPath);
+      if (!fs.existsSync(resolvedWasmPath)) {
+        return {
+          result: null,
+          error: `WASM file not found at provided path: ${resolvedWasmPath}`
+        };
+      }
+    } else {
+      // Check Rust build output location
+      const rustWasmPath = path.join(functionDir, 'target', 'wasm32-wasip1', 'release', `${functionName}.wasm`);
+      if (fs.existsSync(rustWasmPath)) {
+        resolvedWasmPath = rustWasmPath;
+      } else {
+        // Check dist folder (JavaScript functions)
+        const distWasmPath = path.join(functionDir, 'dist', 'function.wasm');
+        if (fs.existsSync(distWasmPath)) {
+          resolvedWasmPath = distWasmPath;
+        }
+      }
+
+      if (!resolvedWasmPath) {
+        return {
+          result: null,
+          error: `WASM file not found in function directory: ${functionDir}`
+        };
+      }
+    }
+
+    const schemaPath = path.join(functionDir, 'schema.graphql');
+    const queryPath = path.join(functionDir, 'src', `${exportName}.graphql`);
+
+    return new Promise((resolve) => {
+      const runnerProcess = spawn('function-runner', [
+        '-f', resolvedWasmPath,
+        '-e', exportName,
+        '--json',
+        '-s', schemaPath,
+        '-q', queryPath
+      ], {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      runnerProcess.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      runnerProcess.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      runnerProcess.on('close', (code) => {
+        if (code !== 0) {
+          resolve({
+            result: null,
+            error: `function-runner failed with exit code ${code}: ${stderr}`
+          });
+          return;
+        }
+
+        try {
+          const result = JSON.parse(stdout);
+
+          // function-runner output format: { output: {...} }
+          resolve({
+            result: { output: result.output || result },
+            error: null
+          });
+        } catch (parseError) {
+          resolve({
+            result: null,
+            error: `Failed to parse function-runner output: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`
+          });
+        }
+      });
+
+      runnerProcess.on('error', (error) => {
+        resolve({
+          result: null,
+          error: `Failed to start function-runner: ${error.message}`
+        });
+      });
+
+      runnerProcess.stdin.write(inputJson);
+      runnerProcess.stdin.end();
+    });
+
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        result: null,
+        error: error.message
+      };
+    } else {
+      return {
+        result: null,
+        error: 'Unknown error occurred'
+      };
+    }
+  }
+}
+

src/wasm-testing-helpers.ts

@@ -10,7 +10,7 @@ import { loadFixture } from './methods/load-fixture.js';
 import { loadSchema } from './methods/load-schema.js';
 import { loadInputQuery } from './methods/load-input-query.js';
 import { buildFunction } from './methods/build-function.js';
-import { runFunction } from './methods/run-function.js';
+import { runFunction, runFunctionWithRunnerDirectly } from './methods/run-function.js';
 import { validateTestAssets } from './methods/validate-test-assets.js';
 import { validateInputQuery } from './methods/validate-input-query.js';
 import { validateFixtureInputStructure } from './methods/validate-fixture-input-structure.js';
@@ -24,6 +24,7 @@ export {
   loadInputQuery,
   buildFunction,
   runFunction,
+  runFunctionWithRunnerDirectly,
   validateTestAssets,
   validateInputQuery,
   validateFixtureInputStructure,

test/methods/run-function.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { runFunction } from '../../src/methods/run-function.ts';
+import { runFunction, runFunctionWithRunnerDirectly } from '../../src/methods/run-function.ts';
 import { loadFixture } from '../../src/methods/load-fixture.ts';
 
 describe('runFunction', () => {
@@ -31,11 +31,93 @@ describe('runFunction', () => {
 
     it('should work with fixture data', async () => {
       const fixture = await loadFixture('test-app/extensions/cart-validation-js/tests/fixtures/cda6d1.json');
-      
+
       const result = await runFunction(fixture.export, fixture.input, 'test-app/extensions/cart-validation-js');
-      
+
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty('result');
+      expect(result).toHaveProperty('error');
+    });
+  });
+
+describe('runFunctionWithRunnerDirectly', () => {
+    it('should run a function using function-runner directly', async () => {
+      const exportName = 'cart-validations-generate-run';
+      const input = {
+        cart: {
+          lines: [{ quantity: 1 }]
+        }
+      };
+
+      const result = await runFunctionWithRunnerDirectly(exportName, input, 'test-app/extensions/cart-validation-js');
+
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty('result');
+      expect(result).toHaveProperty('error');
+
+      // If function-runner is available, should succeed
+      if (result.error === null) {
+        expect(result.result).toBeDefined();
+        expect(result.result).toHaveProperty('output');
+      }
+    });
+
+    it('should handle missing WASM file gracefully', async () => {
+      const exportName = 'cart-validations-generate-run';
+      const input = { cart: { lines: [] } };
+
+      const result = await runFunctionWithRunnerDirectly(exportName, input, 'nonexistent-function');
+
+      expect(result).toBeDefined();
+      expect(result.error).toContain('WASM file not found');
+    });
+
+    it('should work with fixture data', async () => {
+      const fixture = await loadFixture('test-app/extensions/cart-validation-js/tests/fixtures/cda6d1.json');
+
+      const result = await runFunctionWithRunnerDirectly(fixture.export, fixture.input, 'test-app/extensions/cart-validation-js');
+
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty('result');
+      expect(result).toHaveProperty('error');
+
+      // If function-runner is available and function is built, should succeed
+      if (result.error === null) {
+        expect(result.result).toBeDefined();
+        expect(result.result).toHaveProperty('output');
+      }
+    });
+
+    it('should work with direct WASM path', async () => {
+      const exportName = 'cart-validations-generate-run';
+      const input = {
+        cart: {
+          lines: [{ quantity: 1 }]
+        }
+      };
+      const wasmPath = 'test-app/extensions/cart-validation-js/dist/function.wasm';
+
+      const result = await runFunctionWithRunnerDirectly(exportName, input, 'test-app/extensions/cart-validation-js', wasmPath);
+
       expect(result).toBeDefined();
       expect(result).toHaveProperty('result');
       expect(result).toHaveProperty('error');
+
+      // If function-runner is available and WASM file exists, should succeed
+      if (result.error === null) {
+        expect(result.result).toBeDefined();
+        expect(result.result).toHaveProperty('output');
+      }
+    });
+
+    it('should handle invalid WASM path', async () => {
+      const exportName = 'cart-validations-generate-run';
+      const input = { cart: { lines: [] } };
+      const wasmPath = 'nonexistent/path/to/function.wasm';
+
+      const result = await runFunctionWithRunnerDirectly(exportName, input, 'test-app/extensions/cart-validation-js', wasmPath);
+
+      expect(result).toBeDefined();
+      expect(result.error).toContain('WASM file not found at provided path');
     });
   });