fix(jotform): keep the callback when an active deployment still needs it

Redeploying prepares the replacement webhook row alongside the live one and
a workflow keeps its path across deployments, so both rows resolve to a
single callback on a single form. Registration adopts the callback already
present instead of posting a duplicate, which left the retired row's
cleanup deleting the one the new row had just adopted — the trigger went
silent after a redeploy that changed the trigger config.

Teardown now skips when another webhook row belonging to an active
deployment resolves to the same form and callback URL, matching how the
Telegram handler skips deleteWebhook while an active deployment still uses
the same bot. A genuine undeploy has no such row and still cleans up.

Author: waleedlatif1

apps/sim/lib/webhooks/providers/jotform.test.ts

@@ -1,15 +1,19 @@
 /**
  * @vitest-environment node
  */
+import { dbChainMock, queueTableRows, resetDbChainMock, schemaMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+vi.mock('@sim/db', () => ({ ...dbChainMock, ...schemaMock }))
+
 const WEBHOOK_ID = 'webhook-uuid-1234'
 const NOTIFICATION_URL = 'https://app.example.com/api/webhooks/trigger/jotform-path'
 
 vi.mock('@/lib/webhooks/provider-subscription-utils', () => ({
   getProviderConfig: (webhook: { providerConfig?: Record<string, unknown> }) =>
     webhook.providerConfig || {},
-  getNotificationUrl: () => NOTIFICATION_URL,
+  getNotificationUrl: (webhook: { path?: string | null }) =>
+    `https://app.example.com/api/webhooks/trigger/${webhook.path ?? 'jotform-path'}`,
 }))
 
 import { jotformHandler } from '@/lib/webhooks/providers/jotform'
@@ -18,7 +22,7 @@ const fetchMock = vi.fn()
 
 function createContext(providerConfig: Record<string, unknown>) {
   return {
-    webhook: { id: WEBHOOK_ID, path: 'jotform-path', providerConfig },
+    webhook: { id: WEBHOOK_ID, workflowId: 'wf-1', path: 'jotform-path', providerConfig },
     workflow: {},
     userId: 'user-1',
     requestId: 'req-1',
@@ -201,6 +205,7 @@ describe('jotformHandler createSubscription', () => {
 describe('jotformHandler deleteSubscription', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    resetDbChainMock()
     vi.stubGlobal('fetch', fetchMock)
   })
 
@@ -226,6 +231,44 @@ describe('jotformHandler deleteSubscription', () => {
     expect(fetchMock).toHaveBeenCalledTimes(1)
   })
 
+  /**
+   * Redeploying prepares the replacement row before the retired row is cleaned up, and the
+   * workflow keeps its path, so both rows name one callback on one form. Without the guard
+   * the retired row's cleanup deletes the callback the live row is now relying on and the
+   * trigger goes silent.
+   */
+  it('leaves the callback alone while an active deployment is served by it', async () => {
+    queueTableRows(schemaMock.webhook, [{ path: 'jotform-path', providerConfig: { formId: '1' } }])
+
+    await jotformHandler.deleteSubscription!(createContext({ formId: '1', apiKey: 'jf-key' }))
+
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('still deletes when the active deployment points at a different form', async () => {
+    queueTableRows(schemaMock.webhook, [
+      { path: 'jotform-path', providerConfig: { formId: '999' } },
+    ])
+    fetchMock
+      .mockResolvedValueOnce(envelope({ '0': NOTIFICATION_URL }))
+      .mockResolvedValueOnce(envelope({}))
+
+    await jotformHandler.deleteSubscription!(createContext({ formId: '1', apiKey: 'jf-key' }))
+
+    expect(fetchMock.mock.calls[1][1].method).toBe('DELETE')
+  })
+
+  it('still deletes when the active deployment is served by a different path', async () => {
+    queueTableRows(schemaMock.webhook, [{ path: 'other-path', providerConfig: { formId: '1' } }])
+    fetchMock
+      .mockResolvedValueOnce(envelope({ '0': NOTIFICATION_URL }))
+      .mockResolvedValueOnce(envelope({}))
+
+    await jotformHandler.deleteSubscription!(createContext({ formId: '1', apiKey: 'jf-key' }))
+
+    expect(fetchMock.mock.calls[1][1].method).toBe('DELETE')
+  })
+
   it('swallows a failed cleanup unless the caller is strict', async () => {
     fetchMock.mockRejectedValue(new Error('network down'))
 

apps/sim/lib/webhooks/providers/jotform.ts

@@ -1,6 +1,8 @@
+import { db, webhook, workflowDeploymentVersion } from '@sim/db'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { isRecordLike } from '@sim/utils/object'
+import { and, eq, isNull, ne } from 'drizzle-orm'
 import { getNotificationUrl, getProviderConfig } from '@/lib/webhooks/provider-subscription-utils'
 import type {
   DeleteSubscriptionContext,
@@ -76,6 +78,53 @@ async function listWebhookIdForUrl(
   return findWebhookIdByUrl(envelope.content, notificationUrl)
 }
 
+/**
+ * Reports whether another webhook row belonging to an active deployment is served by the
+ * same Jotform callback — the same form and the same URL.
+ *
+ * Redeploying a trigger prepares the replacement row alongside the live one, and a workflow
+ * keeps its webhook path across deployments, so both rows resolve to one callback on one
+ * form. Registration adopts the callback already there instead of posting a duplicate, which
+ * leaves the retired row's cleanup pointing at the callback the new row now depends on.
+ * Teardown is skipped in that case, exactly as the Telegram handler skips `deleteWebhook`
+ * while an active deployment still uses the same bot.
+ */
+async function activeDeploymentSharesJotformCallback(
+  webhookRecord: Record<string, unknown>,
+  formId: string,
+  notificationUrl: string
+): Promise<boolean> {
+  const workflowId = webhookRecord.workflowId
+  const webhookId = webhookRecord.id
+  if (typeof workflowId !== 'string' || typeof webhookId !== 'string') return false
+
+  const activeWebhooks = await db
+    .select({ path: webhook.path, providerConfig: webhook.providerConfig })
+    .from(webhook)
+    .innerJoin(
+      workflowDeploymentVersion,
+      eq(webhook.deploymentVersionId, workflowDeploymentVersion.id)
+    )
+    .where(
+      and(
+        eq(webhook.workflowId, workflowId),
+        ne(webhook.id, webhookId),
+        eq(webhook.provider, 'jotform'),
+        eq(workflowDeploymentVersion.workflowId, workflowId),
+        eq(workflowDeploymentVersion.isActive, true),
+        isNull(webhook.archivedAt)
+      )
+    )
+
+  return activeWebhooks.some((activeWebhook) => {
+    const config = getProviderConfig({ providerConfig: activeWebhook.providerConfig })
+    return (
+      toStringOrNull(config.formId)?.trim() === formId &&
+      sameUrl(getNotificationUrl({ path: activeWebhook.path }), notificationUrl)
+    )
+  })
+}
+
 export const jotformHandler: WebhookProviderHandler = {
   async formatInput({ body }: FormatInputContext): Promise<FormatInputResult> {
     const payload = isRecordLike(body) ? body : {}
@@ -184,6 +233,20 @@ export const jotformHandler: WebhookProviderHandler = {
     const notificationUrl = getNotificationUrl(ctx.webhook)
 
     try {
+      if (
+        await activeDeploymentSharesJotformCallback(
+          ctx.webhook,
+          credentials.formId,
+          notificationUrl
+        )
+      ) {
+        logger.info(
+          `[${ctx.requestId}] Skipping Jotform webhook deletion because an active deployment is served by the same callback`,
+          { webhookId: ctx.webhook.id }
+        )
+        return
+      }
+
       const webhookId = await listWebhookIdForUrl(credentials, notificationUrl)
 
       if (!webhookId) {