chore(workflows): scope the paused-row read to its workflow and reuse the mutability guard

- the execution-status paused-row read filters by workflowId as well
- delete-workflow uses requireMutableWorkflow instead of an inline copy
- polling webhook logs carry the webhook id in metadata

Author: waleedlatif1

apps/sim/lib/webhooks/polling/utils.ts

@@ -64,7 +64,9 @@ export function throwIfAdmissionRefused(result: PolledWebhookEventResult): void
 
 /** Logs a poll stopped by {@link PollAdmissionRefusedError} and reports it as skipped. */
 export function skipAdmissionRefusedPoll(logger: Logger, webhookId: string): 'skipped' {
-  logger.info(`Execution admission refused webhook ${webhookId}; left its items for a later poll`)
+  logger.info('Execution admission refused the webhook; left its items for a later poll', {
+    webhookId,
+  })
   return 'skipped'
 }
 
@@ -175,12 +177,13 @@ export async function markWebhookFailed(webhookId: string, logger: Logger): Prom
       .returning({ isActive: webhook.isActive, wasActive: prior.wasActive })
 
     if (result?.wasActive && !result.isActive) {
-      logger.warn(
-        `Webhook ${webhookId} auto-disabled after ${MAX_CONSECUTIVE_FAILURES} consecutive failures`
-      )
+      logger.warn('Webhook auto-disabled after consecutive failures', {
+        webhookId,
+        consecutiveFailures: MAX_CONSECUTIVE_FAILURES,
+      })
     }
   } catch (err) {
-    logger.error(`Failed to mark webhook ${webhookId} as failed:`, err)
+    logger.error('Failed to mark webhook as failed', { webhookId, error: err })
   }
 }
 
@@ -197,7 +200,7 @@ export async function markWebhookSuccess(webhookId: string, logger: Logger): Pro
         and(eq(webhook.id, webhookId), or(isNull(webhook.failedCount), ne(webhook.failedCount, 0)))
       )
   } catch (err) {
-    logger.error(`Failed to mark webhook ${webhookId} as successful:`, err)
+    logger.error('Failed to mark webhook as successful', { webhookId, error: err })
   }
 }
 
@@ -322,7 +325,7 @@ export async function updateWebhookProviderConfig(
       })
       .where(eq(webhook.id, webhookId))
   } catch (err) {
-    logger.error(`Failed to update webhook ${webhookId} config:`, err)
+    logger.error('Failed to update webhook config', { webhookId, error: err })
   }
 }
 

apps/sim/lib/workflows/application/delete-workflow.ts

@@ -1,10 +1,9 @@
 import { AuditAction, AuditResourceType } from '@sim/audit'
 import { resolvePrincipalAttribution } from '@sim/auth/principal'
 import { createLogger } from '@sim/logger'
-import { assertWorkflowMutable, WorkflowLockedError } from '@sim/platform-authz/workflow'
-import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { notifyWorkflowDeleted, notifyWorkspaceWorkflowsChanged } from '@/lib/realtime/notify'
 import { defineAuthorizedWorkflowUseCase } from '@/lib/workflows/application/authorized-workflow-use-case'
+import { requireMutableWorkflow } from '@/lib/workflows/application/mutability'
 import { workflowOperations } from '@/lib/workflows/application/operations'
 import { resolvePrincipalWorkflowContext } from '@/lib/workflows/application/principal-scope'
 import { requireWorkflowTransition } from '@/lib/workflows/application/transition-result'
@@ -21,14 +20,7 @@ export const deleteWorkflow = defineAuthorizedWorkflowUseCase({
   operation: workflowOperations.delete,
   resolveContext: resolvePrincipalWorkflowContext<DeleteWorkflowInput>,
   async execute({ principal, context }) {
-    try {
-      await assertWorkflowMutable(context.workflowId)
-    } catch (error) {
-      if (error instanceof WorkflowLockedError) {
-        throw new OrchestrationError('locked', error.message)
-      }
-      throw error
-    }
+    await requireMutableWorkflow(context.workflowId)
 
     const transition = await deleteWorkflowRecord({
       workflowId: context.workflowId,

apps/sim/lib/workflows/executor/execution-status.ts

@@ -493,7 +493,12 @@ async function readWorkflowExecutionStatus(
       nextResumeAt: pausedExecutions.nextResumeAt,
     })
     .from(pausedExecutions)
-    .where(eq(pausedExecutions.executionId, executionId))
+    .where(
+      and(
+        eq(pausedExecutions.executionId, executionId),
+        eq(pausedExecutions.workflowId, workflowId)
+      )
+    )
     .limit(1)
 
   const isCurrentlyPaused =