calcom
diff --git a/‎apps/web/app/api/routing-forms/queued-response/__tests__/queued-response.test.ts‎
Lines changed: 52 additions & 0 deletions b/‎apps/web/app/api/routing-forms/queued-response/__tests__/queued-response.test.ts‎
Lines changed: 52 additions & 0 deletions
diff --git a/‎apps/web/app/api/routing-forms/queued-response/route.ts‎
Lines changed: 7 additions & 0 deletions b/‎apps/web/app/api/routing-forms/queued-response/route.ts‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎apps/web/modules/webhooks/components/WebhookForm.tsx‎
Lines changed: 1 addition & 0 deletions b/‎apps/web/modules/webhooks/components/WebhookForm.tsx‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎packages/app-store/routing-forms/lib/formSubmissionUtils.test.ts‎
Lines changed: 212 additions & 0 deletions b/‎packages/app-store/routing-forms/lib/formSubmissionUtils.test.ts‎
Lines changed: 212 additions & 0 deletions
@@ -42,6 +42,7 @@ const mockQueuedFormResponse = {
     disabled: false,
   },
   chosenRouteId: "mock-chosen-route-id",
+  fallbackAction: null,
   createdAt: new Date(),
   updatedAt: new Date(),
   response: {},
@@ -126,6 +127,57 @@ describe("queuedResponseHandler", () => {
     });
   });
 
+  it("should pass fallbackAction to onSubmissionOfFormResponse when present", async () => {
+    const fallbackAction = {
+      type: "eventTypeRedirectUrl" as const,
+      value: "team/fallback-event",
+      eventTypeId: 42,
+    };
+
+    vi.mocked(mockRoutingFormResponseRepository.getQueuedFormResponseFromId).mockResolvedValue({
+      ...mockQueuedFormResponse,
+      fallbackAction,
+    });
+
+    vi.mocked(getSerializableForm).mockResolvedValue({
+      id: "mock-form-id",
+      name: "Test Form",
+      description: "Test Form Description",
+      fields: [],
+      routes: [],
+      userId: 1,
+      teamId: null,
+      position: 1,
+      updatedById: null,
+      disabled: false,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      settings: {},
+    } as unknown as Awaited<ReturnType<typeof getSerializableForm>>);
+
+    vi.mocked(getResponseToStore).mockReturnValue({} as ReturnType<typeof getResponseToStore>);
+
+    vi.mocked(onSubmissionOfFormResponse).mockResolvedValue(undefined as unknown as Awaited<
+      ReturnType<typeof onSubmissionOfFormResponse>
+    >);
+
+    vi.mocked(mockRoutingFormResponseRepository.recordFormResponse).mockResolvedValue({
+      id: 1,
+      response: {},
+    } as Awaited<ReturnType<typeof mockRoutingFormResponseRepository.recordFormResponse>>);
+
+    await queuedResponseHandler({
+      queuedFormResponseId: "1",
+      params: {},
+    });
+
+    expect(onSubmissionOfFormResponse).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fallbackAction,
+      })
+    );
+  });
+
   it("if no queued form response is found, should return early", async () => {
     vi.mocked(mockRoutingFormResponseRepository.getQueuedFormResponseFromId).mockResolvedValue(null);
     const response = await queuedResponseHandler({
 
@@ -72,13 +72,20 @@ export const queuedResponseHandler = async ({
   }
 
   const chosenRoute = serializableForm.routes?.find((r) => r.id === queuedFormResponse.chosenRouteId);
+  const fallbackAction = queuedFormResponse.fallbackAction as {
+    type: "customPageMessage" | "externalRedirectUrl" | "eventTypeRedirectUrl";
+    value: string;
+    eventTypeId?: number;
+  } | null;
+
   await onSubmissionOfFormResponse({
     form: {
       ...queuedFormResponse.form,
       ...serializableForm,
     },
     formResponseInDb: formResponse,
     chosenRouteAction: chosenRoute ? ("action" in chosenRoute ? chosenRoute.action : null) : null,
+    fallbackAction,
   });
 
   return {
 
@@ -73,6 +73,7 @@ const WEBHOOK_TRIGGER_EVENTS_GROUPED_BY_APP_V2: Record<string, WebhookTriggerEve
   "routing-forms": [
     { value: WebhookTriggerEvents.FORM_SUBMITTED, label: "form_submitted" },
     { value: WebhookTriggerEvents.FORM_SUBMITTED_NO_EVENT, label: "form_submitted_no_event" },
+    { value: WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT, label: "routing_form_fallback_hit_trigger" },
   ],
 } as const;
 
 
@@ -397,3 +397,215 @@ describe("_onFormSubmission", () => {
     });
   });
 });
+
+describe("_onFormSubmission with fallbackAction", () => {
+  const mockForm = {
+    id: "form-1",
+    name: "Test Form",
+    disabled: false,
+    userId: 1,
+    position: 0,
+    description: null,
+    updatedById: null,
+    fields: [
+      { id: "field-1", identifier: "email", label: "Email", type: "email", required: false },
+    ] as Field[],
+    user: { id: 1, email: "test@example.com", timeFormat: 12, locale: "en" },
+    teamId: 1,
+    settings: {},
+    routes: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    connectedForms: [],
+    routers: [],
+    teamMembers: [],
+  };
+
+  const mockResponse: FormResponse = {
+    "field-1": { label: "Email", value: "test@response.com" },
+  };
+
+  const mockFallbackAction = {
+    type: "externalRedirectUrl" as const,
+    value: "https://example.com/fallback",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should fetch ROUTING_FORM_FALLBACK_HIT webhooks when fallbackAction is provided", async () => {
+    vi.mocked(getWebhooks).mockResolvedValue([]);
+
+    await _onFormSubmission(mockForm, mockResponse, 123, undefined, mockFallbackAction);
+
+    expect(getWebhooks).toHaveBeenCalledWith({
+      userId: null,
+      teamId: 1,
+      orgId: 1,
+      triggerEvent: WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT,
+    });
+  });
+
+  it("should not fetch ROUTING_FORM_FALLBACK_HIT webhooks when fallbackAction is not provided", async () => {
+    vi.mocked(getWebhooks).mockResolvedValue([]);
+
+    await _onFormSubmission(mockForm, mockResponse, 123);
+
+    const calls = vi.mocked(getWebhooks).mock.calls;
+    const fallbackCalls = calls.filter(
+      (call) => call[0].triggerEvent === WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT
+    );
+    expect(fallbackCalls).toHaveLength(0);
+  });
+
+  it("should send ROUTING_FORM_FALLBACK_HIT webhook payload with correct data", async () => {
+    const mockWebhook: WebhookSubscriber = {
+      id: "wh-1",
+      secret: "secret",
+      subscriberUrl: "https://example.com/webhook",
+      payloadTemplate: null,
+      appId: null,
+      eventTriggers: [WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT],
+      time: null,
+      timeUnit: null,
+      version: WebhookVersionEnum.V_2021_10_20,
+    };
+    vi.mocked(getWebhooks).mockImplementation(async (opts) => {
+      if (opts.triggerEvent === WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT) {
+        return [mockWebhook];
+      }
+      return [];
+    });
+
+    await _onFormSubmission(mockForm, mockResponse, 123, undefined, mockFallbackAction);
+
+    expect(sendGenericWebhookPayload).toHaveBeenCalledWith(
+      expect.objectContaining({
+        secretKey: "secret",
+        triggerEvent: "ROUTING_FORM_FALLBACK_HIT",
+        webhook: mockWebhook,
+        data: {
+          formId: "form-1",
+          formName: "Test Form",
+          teamId: 1,
+          responseId: 123,
+          fallbackAction: {
+            type: "externalRedirectUrl",
+            value: "https://example.com/fallback",
+          },
+          responses: mockResponse,
+        },
+      })
+    );
+  });
+
+  it("should include eventTypeId in fallbackAction payload when present", async () => {
+    const mockWebhook: WebhookSubscriber = {
+      id: "wh-1",
+      secret: "secret",
+      subscriberUrl: "https://example.com/webhook",
+      payloadTemplate: null,
+      appId: null,
+      eventTriggers: [WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT],
+      time: null,
+      timeUnit: null,
+      version: WebhookVersionEnum.V_2021_10_20,
+    };
+    vi.mocked(getWebhooks).mockImplementation(async (opts) => {
+      if (opts.triggerEvent === WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT) {
+        return [mockWebhook];
+      }
+      return [];
+    });
+
+    const fallbackWithEventType = {
+      type: "eventTypeRedirectUrl" as const,
+      value: "team/30min",
+      eventTypeId: 42,
+    };
+
+    await _onFormSubmission(mockForm, mockResponse, 123, undefined, fallbackWithEventType);
+
+    expect(sendGenericWebhookPayload).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          fallbackAction: {
+            type: "eventTypeRedirectUrl",
+            value: "team/30min",
+            eventTypeId: 42,
+          },
+        }),
+      })
+    );
+  });
+
+  it("should send to multiple ROUTING_FORM_FALLBACK_HIT webhooks", async () => {
+    const mockWebhooks: WebhookSubscriber[] = [
+      {
+        id: "wh-1",
+        secret: "secret1",
+        subscriberUrl: "https://example.com/webhook1",
+        payloadTemplate: null,
+        appId: null,
+        eventTriggers: [WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT],
+        time: null,
+        timeUnit: null,
+        version: WebhookVersionEnum.V_2021_10_20,
+      },
+      {
+        id: "wh-2",
+        secret: "secret2",
+        subscriberUrl: "https://example.com/webhook2",
+        payloadTemplate: null,
+        appId: null,
+        eventTriggers: [WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT],
+        time: null,
+        timeUnit: null,
+        version: WebhookVersionEnum.V_2021_10_20,
+      },
+    ];
+    vi.mocked(getWebhooks).mockImplementation(async (opts) => {
+      if (opts.triggerEvent === WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT) {
+        return mockWebhooks;
+      }
+      return [];
+    });
+
+    await _onFormSubmission(mockForm, mockResponse, 123, undefined, mockFallbackAction);
+
+    const fallbackCalls = vi.mocked(sendGenericWebhookPayload).mock.calls.filter(
+      (call) => call[0].triggerEvent === "ROUTING_FORM_FALLBACK_HIT"
+    );
+    expect(fallbackCalls).toHaveLength(2);
+  });
+
+  it("should not throw when ROUTING_FORM_FALLBACK_HIT webhook payload fails", async () => {
+    const mockWebhook: WebhookSubscriber = {
+      id: "wh-1",
+      secret: "secret",
+      subscriberUrl: "https://example.com/webhook",
+      payloadTemplate: null,
+      appId: null,
+      eventTriggers: [WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT],
+      time: null,
+      timeUnit: null,
+      version: WebhookVersionEnum.V_2021_10_20,
+    };
+    vi.mocked(getWebhooks).mockImplementation(async (opts) => {
+      if (opts.triggerEvent === WebhookTriggerEvents.ROUTING_FORM_FALLBACK_HIT) {
+        return [mockWebhook];
+      }
+      return [];
+    });
+    vi.mocked(sendGenericWebhookPayload).mockRejectedValueOnce(new Error("Network error"));
+
+    await expect(
+      _onFormSubmission(mockForm, mockResponse, 123, undefined, mockFallbackAction)
+    ).resolves.not.toThrow();
+  });
+});