fix(supabase): only parse Edge Function body/headers for invoke_function

Stale or invalid functionBody/functionHeaders left in the block (common when
switching operations) were parsed and validated for every operation, so they
could throw before unrelated tools ran even while hidden. Moved parsing and
validation inside the invoke_function guard; added a regression test.

Author: waleedlatif1

apps/sim/blocks/blocks/supabase.test.ts

@@ -30,6 +30,21 @@ describe('SupabaseBlock', () => {
     expect(params).not.toHaveProperty('headers')
   })
 
+  it('ignores stale invalid Edge Function fields on other operations', () => {
+    // Hidden Edge Function inputs left over from a prior selection must not be
+    // parsed/validated (and must never throw) for unrelated operations.
+    expect(() =>
+      buildParams({
+        operation: 'query',
+        projectId: 'proj',
+        apiKey: 'key',
+        table: 'users',
+        functionBody: '{not valid json',
+        functionHeaders: '["a","b"]',
+      })
+    ).not.toThrow()
+  })
+
   it('passes method, body, and headers through for invoke_function', () => {
     const params = buildParams({
       operation: 'invoke_function',

apps/sim/blocks/blocks/supabase.ts

@@ -1095,45 +1095,6 @@ Return ONLY the PostgREST filter expression - no explanations, no markdown, no e
           parsedPaths = paths
         }
 
-        let parsedFunctionBody
-        if (functionBody && typeof functionBody === 'string' && functionBody.trim()) {
-          try {
-            parsedFunctionBody = JSON.parse(functionBody)
-          } catch (parseError) {
-            const errorMsg = getErrorMessage(parseError, 'Unknown JSON error')
-            throw new Error(
-              `Invalid Edge Function body format: ${errorMsg}. Please provide a valid JSON object.`
-            )
-          }
-        } else if (functionBody && typeof functionBody === 'object') {
-          parsedFunctionBody = functionBody
-        }
-
-        let parsedFunctionHeaders
-        if (functionHeaders && typeof functionHeaders === 'string' && functionHeaders.trim()) {
-          try {
-            parsedFunctionHeaders = JSON.parse(functionHeaders)
-          } catch (parseError) {
-            const errorMsg = getErrorMessage(parseError, 'Unknown JSON error')
-            throw new Error(
-              `Invalid Edge Function headers format: ${errorMsg}. Please provide a valid JSON object.`
-            )
-          }
-        } else if (functionHeaders && typeof functionHeaders === 'object') {
-          parsedFunctionHeaders = functionHeaders
-        }
-
-        if (
-          parsedFunctionHeaders !== undefined &&
-          (typeof parsedFunctionHeaders !== 'object' ||
-            parsedFunctionHeaders === null ||
-            Array.isArray(parsedFunctionHeaders))
-        ) {
-          throw new Error(
-            'Edge Function headers must be a JSON object of header name to value (not an array).'
-          )
-        }
-
         let parsedAllowedMimeTypes
         if (allowedMimeTypes && typeof allowedMimeTypes === 'string' && allowedMimeTypes.trim()) {
           try {
@@ -1174,11 +1135,47 @@ Return ONLY the PostgREST filter expression - no explanations, no markdown, no e
           if (method !== undefined) {
             result.method = method
           }
-          if (parsedFunctionBody !== undefined) {
-            result.body = parsedFunctionBody
+
+          if (functionBody && typeof functionBody === 'string' && functionBody.trim()) {
+            try {
+              result.body = JSON.parse(functionBody)
+            } catch (parseError) {
+              const errorMsg = getErrorMessage(parseError, 'Unknown JSON error')
+              throw new Error(
+                `Invalid Edge Function body format: ${errorMsg}. Please provide a valid JSON object.`
+              )
+            }
+          } else if (functionBody && typeof functionBody === 'object') {
+            result.body = functionBody
           }
-          if (parsedFunctionHeaders !== undefined) {
-            result.headers = parsedFunctionHeaders
+
+          if (functionHeaders) {
+            let parsedHeaders
+            if (typeof functionHeaders === 'string' && functionHeaders.trim()) {
+              try {
+                parsedHeaders = JSON.parse(functionHeaders)
+              } catch (parseError) {
+                const errorMsg = getErrorMessage(parseError, 'Unknown JSON error')
+                throw new Error(
+                  `Invalid Edge Function headers format: ${errorMsg}. Please provide a valid JSON object.`
+                )
+              }
+            } else if (typeof functionHeaders === 'object') {
+              parsedHeaders = functionHeaders
+            }
+
+            if (parsedHeaders !== undefined) {
+              if (
+                typeof parsedHeaders !== 'object' ||
+                parsedHeaders === null ||
+                Array.isArray(parsedHeaders)
+              ) {
+                throw new Error(
+                  'Edge Function headers must be a JSON object of header name to value (not an array).'
+                )
+              }
+              result.headers = parsedHeaders
+            }
           }
         }