refactor: move check to create handler

Author: Udit-takkar

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/event-types.service.ts

@@ -1,4 +1,4 @@
-import { checkSuccessRedirectUrlAllowed, dynamicEvent } from "@calcom/platform-libraries";
+import { dynamicEvent } from "@calcom/platform-libraries";
 import {
   createEventType,
   EventTypesPublic,
@@ -42,12 +42,6 @@ export class EventTypesService_2024_06_14 {
       this.checkHasUserAccessibleEmailBookingField(body.bookingFields);
     }
     await this.checkCanCreateEventType(user.id, body);
-    if (body.successRedirectUrl) {
-      const redirectUrlCheck = await checkSuccessRedirectUrlAllowed({ userId: user.id });
-      if (!redirectUrlCheck.allowed) {
-        throw new ForbiddenException(redirectUrlCheck.reason);
-      }
-    }
     const eventTypeUser = await this.getUserToCreateEvent(user);
 
     const { destinationCalendar: _destinationCalendar, ...rest } = body;

packages/platform/libraries/index.ts

@@ -66,7 +66,6 @@ export { getBookingInfo };
 export { handleCancelBooking };
 
 export { dynamicEvent } from "@calcom/features/eventtypes/lib/defaultEvents";
-export { checkSuccessRedirectUrlAllowed } from "@calcom/features/eventtypes/lib/successRedirectUrlAllowed";
 export { parseBookingLimit } from "@calcom/lib/intervalLimits/isBookingLimits";
 export { parseRecurringEvent } from "@calcom/lib/isRecurringEvent";
 export { bookingMetadataSchema, teamMetadataSchema, userMetadata } from "@calcom/prisma/zod-utils";

packages/trpc/server/routers/viewer/eventTypes/heavy/create.handler.test.ts

@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { TRPCError } from "@trpc/server";
+
+import { createHandler } from "./create.handler";
+
+const mockCreateEventType = vi.fn();
+const mockCheckSuccessRedirectUrlAllowed = vi.fn();
+
+vi.mock("@calcom/features/eventtypes/repositories/eventTypeRepository");
+vi.mock("@calcom/features/eventtypes/lib/successRedirectUrlAllowed", () => ({
+  checkSuccessRedirectUrlAllowed: (...args: unknown[]) => mockCheckSuccessRedirectUrlAllowed(...args),
+}));
+
+describe("createHandler", () => {
+  type CreateHandlerInput = Parameters<typeof createHandler>[0];
+
+  const ctx = {
+    user: {
+      id: 1,
+      role: "USER",
+      organizationId: null,
+      organization: { isOrgAdmin: false },
+      profile: { id: 1 },
+      metadata: {},
+      email: "user@cal.com",
+    },
+    prisma: {},
+  } as unknown as CreateHandlerInput["ctx"];
+
+  const input = {
+    title: "Test Event",
+    slug: "test-event",
+    length: 30,
+    locations: [{ type: "phone" }],
+    successRedirectUrl: "https://cal.com/success",
+  } as unknown as CreateHandlerInput["input"];
+
+  beforeEach(async () => {
+    vi.resetAllMocks();
+    const { EventTypeRepository } = await import(
+      "@calcom/features/eventtypes/repositories/eventTypeRepository"
+    );
+    vi.mocked(EventTypeRepository).mockImplementation(function () {
+      return {
+        create: mockCreateEventType,
+      } as unknown as InstanceType<typeof EventTypeRepository>;
+    });
+    mockCreateEventType.mockResolvedValue({ id: 999 });
+    mockCheckSuccessRedirectUrlAllowed.mockResolvedValue({ allowed: true });
+  });
+
+  it("throws FORBIDDEN when successRedirectUrl is not allowed", async () => {
+    const reason =
+      "Redirect on booking is a feature for team plan users. Please upgrade to a team plan to use this feature.";
+    mockCheckSuccessRedirectUrlAllowed.mockResolvedValue({
+      allowed: false,
+      reason,
+    });
+
+    await expect(createHandler({ ctx, input })).rejects.toThrow(
+      new TRPCError({
+        code: "FORBIDDEN",
+        message: reason,
+      })
+    );
+    expect(mockCreateEventType).not.toHaveBeenCalled();
+  });
+
+  it("creates event type when successRedirectUrl is allowed", async () => {
+    await expect(createHandler({ ctx, input })).resolves.toEqual({ eventType: { id: 999 } });
+    expect(mockCheckSuccessRedirectUrlAllowed).toHaveBeenCalledWith({ userId: 1 });
+    expect(mockCreateEventType).toHaveBeenCalledWith(
+      expect.objectContaining({
+        successRedirectUrl: "https://cal.com/success",
+      })
+    );
+  });
+});

packages/trpc/server/routers/viewer/eventTypes/heavy/create.handler.ts

@@ -2,6 +2,7 @@ import type { z } from "zod";
 
 import { getDefaultLocations } from "@calcom/app-store/_utils/getDefaultLocations";
 import { DailyLocationType } from "@calcom/app-store/constants";
+import { checkSuccessRedirectUrlAllowed } from "@calcom/features/eventtypes/lib/successRedirectUrlAllowed";
 import { EventTypeRepository } from "@calcom/features/eventtypes/repositories/eventTypeRepository";
 import { PermissionCheckService } from "@calcom/features/pbac/services/permission-check.service";
 import type { PrismaClient } from "@calcom/prisma";
@@ -144,6 +145,17 @@ export const createHandler = async ({ ctx, input }: CreateOptions) => {
     }
   }
 
+  const successRedirectUrl = (rest as { successRedirectUrl?: string }).successRedirectUrl;
+  if (successRedirectUrl) {
+    const redirectUrlCheck = await checkSuccessRedirectUrlAllowed({ userId: ctx.user.id });
+    if (!redirectUrlCheck.allowed) {
+      throw new TRPCError({
+        code: "FORBIDDEN",
+        message: redirectUrlCheck.reason,
+      });
+    }
+  }
+
   const profile = ctx.user.profile;
   try {
     const eventTypeRepo = new EventTypeRepository(ctx.prisma);