fix: port-named outputs + durable error propagation for graph execution

- send-email handler returns { result: { complete: true } } matching
  handler.json output port name 'result'
- send-verification-link handler wraps all returns in { result: {...} }
- failGraphExecution now tracks node name in error message:
  '[nodeName] error details'
- failGraphExecution sets error_code = 'NODE_EXECUTION_FAILED' and
  completed_at for proper lifecycle tracking
- Race condition handled: if execution already completed/failed, logs
  a warning instead of swallowing silently
- Removed try/catch wrapper around failGraphExecution — errors from
  the UPDATE propagate to the job queue's handleError
- Updated unit tests for new port-named return values

Author: pyramation

functions/send-email/__tests__/handler.test.ts

@@ -47,18 +47,18 @@ describe('send-email handler', () => {
         { to: 'a@b.com', subject: 'Hi', text: 'hello' },
         createMockContext()
       );
-      expect(result).toEqual({ complete: true });
+      expect(result).toEqual({ result: { complete: true } });
     });
   });
 
   describe('sending', () => {
-    it('returns { complete: true } on valid payload', async () => {
+    it('returns port-named output on valid payload', async () => {
       const handler = loadHandler();
       const result = await handler(
         { to: 'a@b.com', subject: 'Hi', html: '<p>hi</p>' },
         createMockContext()
       );
-      expect(result).toEqual({ complete: true });
+      expect(result).toEqual({ result: { complete: true } });
     });
 
     it('calls postmaster.send by default (not SMTP)', async () => {
@@ -121,13 +121,13 @@ describe('send-email handler', () => {
       process.env.SEND_EMAIL_DRY_RUN = 'true';
     });
 
-    it('returns { complete: true } without sending', async () => {
+    it('returns port-named output without sending', async () => {
       const handler = loadHandler();
       const result = await handler(
         { to: 'a@b.com', subject: 'Hi', html: '<p>hi</p>' },
         createMockContext()
       );
-      expect(result).toEqual({ complete: true });
+      expect(result).toEqual({ result: { complete: true } });
       const postmaster = require('@constructive-io/postmaster');
       const smtp = require('simple-smtp-server');
       expect(postmaster.send).not.toHaveBeenCalled();

functions/send-email/handler.ts

@@ -81,7 +81,7 @@ const handler: FunctionHandler<SendEmailPayload> = async (params) => {
     logger.info('Sent email', logContext);
   }
 
-  return { complete: true };
+  return { result: { complete: true } };
 };
 
 export default handler;

functions/send-verification-link/__tests__/handler.test.ts

@@ -15,7 +15,7 @@ describe('send-verification-link handler (validation)', () => {
       ctx
     );
     expect(result).toEqual({
-      error: 'Missing X-Database-Id header or DEFAULT_DATABASE_ID'
+      result: { error: 'Missing X-Database-Id header or DEFAULT_DATABASE_ID' }
     });
   });
 

functions/send-verification-link/handler.ts

@@ -280,8 +280,10 @@ const sendEmailLink = async (
   }
 
   return {
-    complete: true,
-    ...(isDryRun ? { dryRun: true } : null)
+    result: {
+      complete: true,
+      ...(isDryRun ? { dryRun: true } : null)
+    }
   };
 };
 
@@ -290,7 +292,7 @@ const handler: FunctionHandler<SendEmailParams> = async (params, context) => {
 
   const databaseId = job.databaseId;
   if (!databaseId) {
-    return { error: 'Missing X-Database-Id header or DEFAULT_DATABASE_ID' };
+    return { result: { error: 'Missing X-Database-Id header or DEFAULT_DATABASE_ID' } };
   }
 
   log.info('[send-verification-link] Processing request', {

job/compute-worker/src/index.ts

@@ -404,11 +404,7 @@ export default class ComputeWorker {
       });
 
       if (graphNode) {
-        try {
-          await this.failGraphExecution(payload.execution_id, err.message);
-        } catch (graphErr) {
-          log.error('Failed to mark graph execution as failed', graphErr);
-        }
+        await this.failGraphExecution(payload.execution_id, payload.node_name, err.message);
         // Don't re-throw for graph nodes — execution is already marked failed.
         // Re-throwing would cause the job queue to retry with the same permanent error.
         return;
@@ -545,11 +541,7 @@ export default class ComputeWorker {
 
       // Graph node failure: mark execution as failed
       if (graphNode) {
-        try {
-          await this.failGraphExecution(payload.execution_id, err.message);
-        } catch (graphErr) {
-          log.error('Failed to mark graph execution as failed', graphErr);
-        }
+        await this.failGraphExecution(payload.execution_id, payload.node_name, err.message);
         // Don't re-throw for graph nodes — execution is already marked failed.
         // Re-throwing would cause the job queue to retry with the same permanent error.
         return;
@@ -579,18 +571,32 @@ export default class ComputeWorker {
 
   /**
    * Mark a graph execution as failed when a node errors.
+   * Records both the failing node name and the error message.
+   * Handles the race where execution may already be completed/failed
+   * (e.g. graphOutput finished before a late node failure arrives).
    */
   private async failGraphExecution(
     executionId: string,
+    nodeName: string,
     errorMessage: string
   ): Promise<void> {
-    log.debug('failing graph execution', { executionId, error: errorMessage });
-    await this.pgPool.query(
+    const nodeError = `[${nodeName}] ${errorMessage}`;
+    log.error('graph node failed', { executionId, nodeName, error: errorMessage });
+    const { rowCount } = await this.pgPool.query(
       `UPDATE constructive_compute_private.platform_function_graph_executions
-       SET status = 'failed', error_message = $1
-       WHERE id = $2`,
-      [errorMessage, executionId]
+       SET status = 'failed',
+           error_message = $1,
+           error_code = 'NODE_EXECUTION_FAILED',
+           completed_at = now()
+       WHERE id = $2 AND status = 'running'`,
+      [nodeError, executionId]
     );
+    if (rowCount === 0) {
+      // Execution already completed or failed — log so the error is never invisible
+      log.warn('graph execution already finished; node failure not recorded in status', {
+        executionId, nodeName, error: errorMessage,
+      });
+    }
   }
 
   /**