Skip to content

Scheduling infrastructure for absolutely everyone.

feat: Sink url shortner for sms workflow reminders (#26608)

Amit Sharma353f71bdc69c
diff --git a/.env.example b/.env.example
index e1995a4cc57..5baff90ab3e 100644
--- a/.env.example
+++ b/.env.example
@@ -109,6 +109,15 @@ NEXT_PUBLIC_POSTHOG_HOST=
# Dub Config
DUB_API_KEY=
NEXT_PUBLIC_DUB_PROGRAM_ID=
+# Optional: Domain for SMS workflow shortened links
+DUB_SMS_DOMAIN=
+# Optional: Folder ID to organize SMS workflow shortened links in Dub
+DUB_SMS_FOLDER_ID=
+
+# Sink URL Shortener Config
+SINK_API_URL=
+# API key for Sink authentication
+SINK_API_KEY=
# Zendesk Config
NEXT_PUBLIC_ZENDESK_KEY=
diff --git a/apps/web/modules/feature-flags/hooks/useFlags.ts b/apps/web/modules/feature-flags/hooks/useFlags.ts
index 9038e72b23e..5bf52ababae 100644
--- a/apps/web/modules/feature-flags/hooks/useFlags.ts
+++ b/apps/web/modules/feature-flags/hooks/useFlags.ts
@@ -38,6 +38,7 @@ const initialData: AppFlags = {
"active-user-billing": false,
"sidebar-tips": false,
"signup-watchlist-review": false,
+ "sink-shortener": false,
};
if (process.env.NEXT_PUBLIC_IS_E2E) {
diff --git a/packages/features/ee/workflows/api/scheduleSMSReminders.test.ts b/packages/features/ee/workflows/api/scheduleSMSReminders.test.ts
index df0ea69a0de..1b6b53782e2 100644
--- a/packages/features/ee/workflows/api/scheduleSMSReminders.test.ts
+++ b/packages/features/ee/workflows/api/scheduleSMSReminders.test.ts
@@ -1,88 +1,693 @@
import prismaMock from "@calcom/testing/lib/__mocks__/prismaMock";
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
import { WorkflowActions, WorkflowMethods, WorkflowTemplates } from "@calcom/prisma/enums";
-
-import { handler } from "./scheduleSMSReminders";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockShortenMany = vi.fn();
+vi.mock("@calcom/features/url-shortener/UrlShortenerFactory", () => ({
+ UrlShortenerFactory: {
+ create: async () => ({
+ shortenMany: (...args: unknown[]) => mockShortenMany(...args),
+ }),
+ },
+}));
const mockScheduleSmsOrFallbackEmail = vi.fn();
vi.mock("@calcom/features/ee/workflows/lib/reminders/messageDispatcher", () => ({
scheduleSmsOrFallbackEmail: (...args: unknown[]) => mockScheduleSmsOrFallbackEmail(...args),
}));
+const mockHasAvailableCredits = vi.fn().mockResolvedValue(true);
vi.mock("@calcom/features/ee/billing/credit-service", () => {
return {
- CreditService: class MockCreditService {
- hasAvailableCredits = vi.fn().mockResolvedValue(true);
+ CreditService: class {
+ hasAvailableCredits = mockHasAvailableCredits;
},
};
});
+const mockGetByReferenceUid = vi.fn();
vi.mock("@calcom/features/bookings/repositories/BookingSeatRepository", () => {
return {
- BookingSeatRepository: class MockBookingSeatRepository {
- getByReferenceUidWithAttendeeDetails = vi.fn().mockResolvedValue(null);
+ BookingSeatRepository: class {
+ getByReferenceUidWithAttendeeDetails = (...args: unknown[]) => mockGetByReferenceUid(...args);
},
};
});
-vi.mock("@calcom/features/ee/workflows/lib/alphanumericSenderIdSupport", () => ({
- getSenderId: vi.fn().mockReturnValue("CalCom"),
+vi.mock("@calcom/features/ee/organizations/lib/getBookerUrlServer", () => ({
+ getBookerBaseUrl: vi.fn().mockResolvedValue("https://app.cal.com"),
}));
-vi.mock("@calcom/features/ee/workflows/lib/service/workflowOptOutService", () => ({
- WorkflowOptOutService: {
- addOptOutMessage: vi.fn().mockResolvedValue("message without opt out"),
- },
+vi.mock("@calcom/features/bookings/lib/getCalEventResponses", () => ({
+ getCalEventResponses: vi.fn().mockReturnValue({ responses: {} }),
}));
-vi.mock("@calcom/features/ee/workflows/lib/reminders/templates/smsReminderTemplate", () => ({
- default: vi.fn().mockReturnValue("Test SMS reminder"),
+vi.mock("@calcom/i18n/server", () => ({
+ getTranslation: vi.fn().mockResolvedValue(((key: string) => key) as unknown),
}));
-vi.mock("@calcom/features/ee/workflows/lib/reminders/templates/customTemplate", () => ({
- default: vi.fn().mockReturnValue({ text: "Custom message" }),
+vi.mock("@calcom/lib/constants", () => ({
+ DUB_SMS_DOMAIN: "sms.example.com",
+ DUB_SMS_FOLDER_ID: "folder-123",
}));
-vi.mock("@calcom/features/bookings/lib/getCalEventResponses", () => ({
- getCalEventResponses: vi.fn().mockReturnValue({ responses: {} }),
+vi.mock("../lib/alphanumericSenderIdSupport", () => ({
+ getSenderId: vi.fn().mockReturnValue("CalCom"),
}));
-vi.mock("@calcom/features/ee/organizations/lib/getBookerUrlServer", () => ({
- getBookerBaseUrl: vi.fn().mockResolvedValue("https://app.cal.com"),
+vi.mock("../lib/getWorkflowReminders", () => ({
+ select: { id: true },
+ getWorkflowRecipientEmail: vi.fn().mockReturnValue(null),
}));
-vi.mock("@calcom/ee/workflows/lib/reminders/utils", () => ({
- bulkShortenLinks: vi.fn().mockResolvedValue([
- { shortLink: "https://short.link/meet" },
- { shortLink: "https://short.link/cancel" },
- { shortLink: "https://short.link/reschedule" },
- ]),
+const mockCustomTemplate = vi.fn().mockReturnValue({ text: "Custom SMS message", html: "" });
+vi.mock("../lib/reminders/templates/customTemplate", () => ({
+ default: (...args: unknown[]) => mockCustomTemplate(...args),
}));
-vi.mock("@calcom/i18n/server", () => ({
- getTranslation: vi.fn().mockResolvedValue((key: string) => key),
+const mockSmsReminderTemplate = vi.fn().mockReturnValue("Reminder: Your event is coming up");
+vi.mock("../lib/reminders/templates/smsReminderTemplate", () => ({
+ default: (...args: unknown[]) => mockSmsReminderTemplate(...args),
+}));
+
+const mockAddOptOutMessage = vi.fn().mockResolvedValue("message with opt-out footer");
+vi.mock("../lib/service/workflowOptOutService", () => ({
+ WorkflowOptOutService: {
+ addOptOutMessage: (...args: unknown[]) => mockAddOptOutMessage(...args),
+ },
}));
vi.mock("@calcom/features/ee/workflows/lib/actionHelperFunctions", () => ({
- isAttendeeAction: vi.fn().mockReturnValue(true),
+ isAttendeeAction: vi.fn(
+ (action: string) =>
+ action === "SMS_ATTENDEE" || action === "EMAIL_ATTENDEE" || action === "WHATSAPP_ATTENDEE"
+ ),
}));
-vi.mock("@calcom/features/ee/workflows/lib/getWorkflowReminders", () => ({
- select: {
- id: true,
- scheduledDate: true,
- workflowStep: true,
- booking: true,
- seatReferenceId: true,
- isMandatoryReminder: true,
- uuid: true,
+vi.mock("@calcom/prisma/zod-utils", () => ({
+ bookingMetadataSchema: {
+ parse: vi.fn((metadata: Record<string, unknown>) => metadata || {}),
},
- getWorkflowRecipientEmail: vi.fn().mockReturnValue("[email protected]"),
}));
-function createMockNextRequest(): { headers: { get: (key: string) => string | null }; nextUrl: { searchParams: { get: (key: string) => string | null } } } {
+vi.mock("@calcom/lib/timeFormat", () => ({
+ getTimeFormatStringFromUserTimeFormat: vi.fn().mockReturnValue("h:mma"),
+}));
+
+import { handler } from "./scheduleSMSReminders";
+
+const MOCK_CRON_API_KEY = "test-cron-api-key-123";
+
+function createMockRequest({
+ apiKeyParam = MOCK_CRON_API_KEY,
+ authorizationHeader,
+ skipAuth = false,
+}: {
+ apiKeyParam?: string;
+ authorizationHeader?: string;
+ skipAuth?: boolean;
+} = {}) {
+ const url = new URL("https://app.cal.com/api/workflows/scheduleSMSReminders");
+ if (!skipAuth && !authorizationHeader && apiKeyParam) {
+ url.searchParams.set("apiKey", apiKeyParam);
+ }
+ const headers = new Headers();
+ if (authorizationHeader) {
+ headers.set("authorization", authorizationHeader);
+ }
+ return {
+ headers: {
+ get: (name: string) => headers.get(name),
+ },
+ nextUrl: url,
+ };
+}
+
+function buildMockReminder(overrides: Record<string, unknown> = {}) {
+ return {
+ id: 1,
+ scheduledDate: new Date("2025-06-15T10:00:00Z"),
+ isMandatoryReminder: false,
+ uuid: "uuid-123",
+ seatReferenceId: null,
+ retryCount: 0,
+ workflowStep: {
+ action: WorkflowActions.SMS_ATTENDEE,
+ sendTo: "+15559876543",
+ reminderBody: "Hello {ATTENDEE_NAME}, your event {EVENT_NAME} is coming up!",
+ emailSubject: null,
+ template: WorkflowTemplates.CUSTOM,
+ sender: "CalCom",
+ includeCalendarEvent: false,
+ id: 10,
+ workflow: {
+ userId: 1,
+ teamId: null,
+ },
+ },
+ booking: {
+ startTime: new Date("2025-06-15T10:00:00Z"),
+ endTime: new Date("2025-06-15T11:00:00Z"),
+ location: "https://meet.google.com/test",
+ description: "Test meeting",
+ smsReminderNumber: "+15551234567",
+ userPrimaryEmail: "[email protected]",
+ metadata: {},
+ uid: "booking-uid-123",
+ customInputs: {},
+ responses: {},
+ title: "Test Event",
+ attendees: [
+ {
+ name: "Test Attendee",
+ email: "[email protected]",
+ phoneNumber: "+15551234567",
+ timeZone: "America/New_York",
+ locale: "en",
+ },
+ ],
+ user: {
+ id: 1,
+ email: "[email protected]",
+ name: "Test Organizer",
+ timeZone: "Europe/London",
+ locale: "en",
+ username: "organizer",
+ timeFormat: 12,
+ hideBranding: false,
+ },
+ eventType: {
+ bookingFields: null,
+ title: "Test Event",
+ slug: "test-event",
+ hosts: [],
+ recurringEvent: null,
+ team: { parentId: null, hideBranding: false },
+ customReplyToEmail: null,
+ },
+ },
+ ...overrides,
+ };
+}
+
+describe("scheduleSMSReminders handler", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.unstubAllEnvs();
+ vi.stubEnv("CRON_API_KEY", MOCK_CRON_API_KEY);
+ mockShortenMany.mockResolvedValue([
+ { shortLink: "https://short.link/meet" },
+ { shortLink: "https://short.link/cancel" },
+ { shortLink: "https://short.link/reschedule" },
+ ]);
+ mockCustomTemplate.mockReturnValue({ text: "Custom SMS message", html: "" });
+ mockSmsReminderTemplate.mockReturnValue("Reminder: Your event is coming up");
+ mockAddOptOutMessage.mockResolvedValue("message with opt-out footer");
+ mockScheduleSmsOrFallbackEmail.mockResolvedValue({ sid: "SM123456", emailReminderId: null });
+ prismaMock.profile.findFirst.mockResolvedValue(null);
+ });
+
+ describe("authentication", () => {
+ it("returns 401 when no apiKey is provided", async () => {
+ const req = createMockRequest({ skipAuth: true });
+
+ const response = await handler(req as any);
+ const body = await response.json();
+
+ expect(response.status).toBe(401);
+ expect(body.message).toBe("Not authenticated");
+ });
+
+ it("returns 401 when apiKey does not match CRON_API_KEY", async () => {
+ const req = createMockRequest({ apiKeyParam: "wrong-key" });
+
+ const response = await handler(req as any);
+
+ expect(response.status).toBe(401);
+ });
+
+ it("authenticates via authorization header", async () => {
+ const req = createMockRequest({ skipAuth: true, authorizationHeader: MOCK_CRON_API_KEY });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([]);
+
+ const response = await handler(req as any);
+
+ expect(response.status).toBe(200);
+ });
+
+ it("authenticates via query parameter", async () => {
+ const req = createMockRequest({ apiKeyParam: MOCK_CRON_API_KEY });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([]);
+
+ const response = await handler(req as any);
+
+ expect(response.status).toBe(200);
+ });
+ });
+
+ describe("no reminders found", () => {
+ it("returns ok when no unscheduled reminders exist", async () => {
+ const req = createMockRequest();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([]);
+
+ const response = await handler(req as any);
+ const body = await response.json();
+
+ expect(response.status).toBe(200);
+ expect(body.ok).toBe(true);
+ });
+
+ it("queries with correct filters", async () => {
+ const req = createMockRequest();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([]);
+
+ await handler(req as any);
+
+ const callArgs = prismaMock.workflowReminder.findMany.mock.calls[0][0];
+ expect(callArgs.where.method).toBe(WorkflowMethods.SMS);
+ expect(callArgs.where.scheduled).toBe(false);
+ expect(callArgs.where.scheduledDate).toEqual(
+ expect.objectContaining({
+ gte: expect.any(Date),
+ lte: expect.any(String),
+ })
+ );
+ expect(callArgs.where.retryCount).toEqual({ lt: 3 });
+ });
+ });
+
+ describe("skipping invalid reminders", () => {
+ it("skips when workflowStep is null", async () => {
+ const req = createMockRequest();
+ const invalidReminder = buildMockReminder({ workflowStep: null });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([invalidReminder as any]);
+
+ const response = await handler(req as any);
+
+ expect(mockScheduleSmsOrFallbackEmail).not.toHaveBeenCalled();
+ expect(response.status).toBe(200);
+ });
+
+ it("skips when booking is null", async () => {
+ const req = createMockRequest();
+ const invalidReminder = buildMockReminder({ booking: null });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([invalidReminder as any]);
+
+ const response = await handler(req as any);
+
+ expect(mockScheduleSmsOrFallbackEmail).not.toHaveBeenCalled();
+ expect(response.status).toBe(200);
+ });
+
+ it("continues processing valid reminders after skipping invalid ones", async () => {
+ const req = createMockRequest();
+ const invalidReminder = buildMockReminder({ id: 1, workflowStep: null });
+ const validReminder = buildMockReminder({ id: 2 });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([invalidReminder as any, validReminder as any]);
+
+ await handler(req as any);
+
+ expect(mockScheduleSmsOrFallbackEmail).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe("seated events", () => {
+ it("looks up seat attendee when seatReferenceId is present", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({ seatReferenceId: "seat-ref-123" });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockGetByReferenceUid.mockResolvedValue({
+ attendee: {
+ name: "Seat Attendee",
+ email: "[email protected]",
+ phoneNumber: "+15559999999",
+ timeZone: "US/Pacific",
+ locale: "en",
+ },
+ });
+
+ await handler(req as any);
+
+ expect(mockGetByReferenceUid).toHaveBeenCalledWith("seat-ref-123");
+ });
+
+ it("uses seat attendee data when found", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({ seatReferenceId: "seat-ref-123" });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockGetByReferenceUid.mockResolvedValue({
+ attendee: {
+ name: "Seat Attendee",
+ email: "[email protected]",
+ phoneNumber: "+15559999999",
+ timeZone: "US/Pacific",
+ locale: "en",
+ },
+ });
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.twilioData.phoneNumber).toBe("+15559999999");
+ });
+
+ it("falls back to booking attendee when seat lookup returns null", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({ seatReferenceId: "seat-ref-123" });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockGetByReferenceUid.mockResolvedValue(null);
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.twilioData.phoneNumber).toBe("+15551234567");
+ });
+
+ it("does not query seat repository when seatReferenceId is null", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({ seatReferenceId: null });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ expect(mockGetByReferenceUid).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("action-based field selection", () => {
+ it("uses workflowStep.sendTo for SMS_NUMBER action", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({
+ workflowStep: {
+ ...buildMockReminder().workflowStep,
+ action: WorkflowActions.SMS_NUMBER,
+ sendTo: "+15559876543",
+ },
+ });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.twilioData.phoneNumber).toBe("+15559876543");
+ });
+
+ it("uses targetAttendee.phoneNumber for SMS_ATTENDEE action", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.twilioData.phoneNumber).toBe("+15551234567");
+ });
+ });
+
+ describe("custom reminderBody processing", () => {
+ it("shortens meetingUrl, cancelLink, and rescheduleLink", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const [urls] = mockShortenMany.mock.calls[0];
+ expect(urls).toHaveLength(3);
+ expect(urls[1]).toContain("/booking/booking-uid-123?cancel=true");
+ expect(urls[2]).toContain("/reschedule/booking-uid-123");
+ });
+
+ it("passes shortened URLs to customTemplate variables", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const variables = mockCustomTemplate.mock.calls[0][1];
+ expect(variables.meetingUrl).toBe("https://short.link/meet");
+ expect(variables.cancelLink).toBe("https://short.link/cancel");
+ expect(variables.rescheduleLink).toBe("https://short.link/reschedule");
+ });
+
+ it("fetches organizer profile for booker URL", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ expect(prismaMock.profile.findFirst).toHaveBeenCalledWith(
+ expect.objectContaining({
+ where: { userId: 1 },
+ })
+ );
+ });
+
+ it("falls back to 'en' locale when computed locale is null", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ (reminder.booking as any).attendees[0].locale = null;
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const templateLocale = mockCustomTemplate.mock.calls[0][2];
+ expect(templateLocale).toBe("en");
+ });
+ });
+
+ describe("REMINDER template processing", () => {
+ it("uses smsReminderTemplate when no reminderBody and template is REMINDER", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({
+ workflowStep: {
+ ...buildMockReminder().workflowStep,
+ reminderBody: null,
+ template: WorkflowTemplates.REMINDER,
+ },
+ });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ expect(mockSmsReminderTemplate).toHaveBeenCalled();
+ expect(mockCustomTemplate).not.toHaveBeenCalled();
+ });
+
+ it("does not send SMS when neither reminderBody nor REMINDER template", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({
+ workflowStep: {
+ ...buildMockReminder().workflowStep,
+ reminderBody: null,
+ template: WorkflowTemplates.CUSTOM,
+ },
+ });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ expect(mockScheduleSmsOrFallbackEmail).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("SMS sending and DB updates", () => {
+ it("calls addOptOutMessage before sending", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ expect(mockAddOptOutMessage).toHaveBeenCalled();
+ });
+
+ it("calls scheduleSmsOrFallbackEmail with correct twilioData", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.twilioData).toMatchObject({
+ phoneNumber: "+15551234567",
+ scheduledDate: reminder.scheduledDate,
+ sender: "CalCom",
+ bookingUid: "booking-uid-123",
+ userId: 1,
+ teamId: null,
+ });
+ expect(callArgs.twilioData.body).toBeDefined();
+ expect(callArgs.twilioData.bodyWithoutOptOut).toBeDefined();
+ });
+
+ it("includes fallbackData for attendee actions", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.fallbackData).toBeDefined();
+ expect(callArgs.fallbackData.email).toBe("[email protected]");
+ expect(callArgs.fallbackData.replyTo).toBe("[email protected]");
+ expect(callArgs.fallbackData.workflowStepId).toBe(10);
+ });
+
+ it("does not include fallbackData for non-attendee actions", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({
+ workflowStep: {
+ ...buildMockReminder().workflowStep,
+ action: WorkflowActions.SMS_NUMBER,
+ },
+ });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ const callArgs = mockScheduleSmsOrFallbackEmail.mock.calls[0][0];
+ expect(callArgs.fallbackData).toBeUndefined();
+ });
+
+ it("updates reminder to scheduled=true with SID on success", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockScheduleSmsOrFallbackEmail.mockResolvedValue({ sid: "SM123456", emailReminderId: null });
+
+ await handler(req as any);
+
+ expect(prismaMock.workflowReminder.update).toHaveBeenCalledWith({
+ where: { id: 1 },
+ data: { scheduled: true, referenceId: "SM123456" },
+ });
+ });
+
+ it("deletes SMS reminder when email fallback was used", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockScheduleSmsOrFallbackEmail.mockResolvedValue({ sid: null, emailReminderId: 456 });
+
+ await handler(req as any);
+
+ expect(prismaMock.workflowReminder.delete).toHaveBeenCalledWith({
+ where: { id: 1 },
+ });
+ });
+
+ it("increments retryCount when scheduleSmsOrFallbackEmail returns null", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({ retryCount: 1 });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockScheduleSmsOrFallbackEmail.mockResolvedValue(null);
+
+ await handler(req as any);
+
+ expect(prismaMock.workflowReminder.update).toHaveBeenCalledWith({
+ where: { id: 1 },
+ data: { retryCount: 2 },
+ });
+ });
+
+ it("does not send when sendTo is undefined", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ (reminder.booking as any).attendees[0].phoneNumber = undefined;
+ (reminder.booking as any).smsReminderNumber = null;
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ await handler(req as any);
+
+ expect(mockScheduleSmsOrFallbackEmail).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("error handling", () => {
+ it("increments retryCount on caught exception", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder({ retryCount: 0 });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+ mockScheduleSmsOrFallbackEmail.mockRejectedValue(new Error("Twilio error"));
+
+ await handler(req as any);
+
+ expect(prismaMock.workflowReminder.update).toHaveBeenCalledWith({
+ where: { id: 1 },
+ data: { retryCount: 1 },
+ });
+ });
+
+ it("continues processing after one reminder fails", async () => {
+ const req = createMockRequest();
+ const failingReminder = buildMockReminder({ id: 1, retryCount: 0 });
+ const successReminder = buildMockReminder({ id: 2, retryCount: 0 });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([
+ failingReminder as any,
+ successReminder as any,
+ ]);
+ mockScheduleSmsOrFallbackEmail
+ .mockRejectedValueOnce(new Error("Twilio error"))
+ .mockResolvedValueOnce({ sid: "SM789", emailReminderId: null });
+
+ const response = await handler(req as any);
+
+ expect(prismaMock.workflowReminder.update).toHaveBeenCalledWith({
+ where: { id: 1 },
+ data: { retryCount: 1 },
+ });
+ expect(prismaMock.workflowReminder.update).toHaveBeenCalledWith({
+ where: { id: 2 },
+ data: { scheduled: true, referenceId: "SM789" },
+ });
+ expect(response.status).toBe(200);
+ });
+
+ it("returns 200 with message after processing all reminders", async () => {
+ const req = createMockRequest();
+ const reminder = buildMockReminder();
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder as any]);
+
+ const response = await handler(req as any);
+ const body = await response.json();
+
+ expect(response.status).toBe(200);
+ expect(body.message).toBe("SMS scheduled");
+ });
+ });
+
+ describe("multiple reminders", () => {
+ it("processes each reminder independently", async () => {
+ const req = createMockRequest();
+ const reminder1 = buildMockReminder({ id: 1 });
+ const reminder2 = buildMockReminder({
+ id: 2,
+ workflowStep: {
+ ...buildMockReminder().workflowStep,
+ action: WorkflowActions.SMS_NUMBER,
+ sendTo: "+15559876543",
+ reminderBody: null,
+ template: WorkflowTemplates.REMINDER,
+ },
+ });
+ prismaMock.workflowReminder.findMany.mockResolvedValue([reminder1 as any, reminder2 as any]);
+
+ await handler(req as any);
+
+ expect(mockScheduleSmsOrFallbackEmail).toHaveBeenCalledTimes(2);
+ });
+ });
+});
+
+function createMockNextRequest(): {
+ headers: { get: (key: string) => string | null };
+ nextUrl: { searchParams: { get: (key: string) => string | null } };
+} {
return {
headers: {
get: (key: string) => (key === "authorization" ? "test-api-key" : null),
@@ -95,7 +700,7 @@ function createMockNextRequest(): { headers: { get: (key: string) => string | nu
};
}
-function createMockReminder(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+function createMockReminderForFallback(overrides: Record<string, unknown> = {}): Record<string, unknown> {
const now = new Date();
const scheduledDate = new Date(now.getTime() + 60 * 60 * 1000);
@@ -168,14 +773,17 @@ function createMockReminder(overrides: Record<string, unknown> = {}): Record<str
describe("scheduleSMSReminders handler - smsReminderNumber fallback", () => {
beforeEach(() => {
vi.clearAllMocks();
- process.env.CRON_API_KEY = "test-api-key";
+ vi.unstubAllEnvs();
+ vi.stubEnv("CRON_API_KEY", "test-api-key");
mockScheduleSmsOrFallbackEmail.mockResolvedValue({ sid: "SM123", emailReminderId: null });
+ mockSmsReminderTemplate.mockReturnValue("Test SMS reminder");
+ mockAddOptOutMessage.mockResolvedValue("message without opt out");
prismaMock.workflowReminder.update.mockResolvedValue({} as never);
prismaMock.profile.findFirst.mockResolvedValue(null);
});
it("should use attendee phone when booking has no smsReminderNumber", async () => {
- const reminder = createMockReminder();
+ const reminder = createMockReminderForFallback();
prismaMock.workflowReminder.findMany.mockResolvedValue([reminder] as never);
const req = createMockNextRequest();
@@ -192,8 +800,8 @@ describe("scheduleSMSReminders handler - smsReminderNumber fallback", () => {
});
it("should use smsReminderNumber when booking has it set", async () => {
- const base = createMockReminder();
- const reminder = createMockReminder({
+ const base = createMockReminderForFallback();
+ const reminder = createMockReminderForFallback({
booking: {
...(base.booking as Record<string, unknown>),
smsReminderNumber: "+2222222222",
@@ -215,9 +823,9 @@ describe("scheduleSMSReminders handler - smsReminderNumber fallback", () => {
});
it("should prefer smsReminderNumber over attendee phone for non-seated events", async () => {
- const baseReminder = createMockReminder();
+ const baseReminder = createMockReminderForFallback();
const booking = baseReminder.booking as Record<string, unknown>;
- const reminder = createMockReminder({
+ const reminder = createMockReminderForFallback({
booking: {
...booking,
smsReminderNumber: "+3333333333",
@@ -247,8 +855,8 @@ describe("scheduleSMSReminders handler - smsReminderNumber fallback", () => {
});
it("should use workflowStep.sendTo when action is SMS_NUMBER", async () => {
- const base = createMockReminder();
- const reminder = createMockReminder({
+ const base = createMockReminderForFallback();
+ const reminder = createMockReminderForFallback({
workflowStep: {
...(base.workflowStep as Record<string, unknown>),
action: WorkflowActions.SMS_NUMBER,
@@ -274,9 +882,9 @@ describe("scheduleSMSReminders handler - smsReminderNumber fallback", () => {
});
it("should use smsReminderNumber when attendee has no phone number", async () => {
- const baseReminder = createMockReminder();
+ const baseReminder = createMockReminderForFallback();
const booking = baseReminder.booking as Record<string, unknown>;
- const reminder = createMockReminder({
+ const reminder = createMockReminderForFallback({
booking: {
...booking,
smsReminderNumber: "+5555555555",
diff --git a/packages/features/ee/workflows/api/scheduleSMSReminders.ts b/packages/features/ee/workflows/api/scheduleSMSReminders.ts
index 01a9c585336..9880ef6c03a 100644
--- a/packages/features/ee/workflows/api/scheduleSMSReminders.ts
+++ b/packages/features/ee/workflows/api/scheduleSMSReminders.ts
@@ -1,24 +1,24 @@
/* Schedule any workflow reminder that falls within the next 2 hours for SMS */
-import type { NextRequest } from "next/server";
-import { NextResponse } from "next/server";
import dayjs from "@calcom/dayjs";
-import { bulkShortenLinks } from "@calcom/ee/workflows/lib/reminders/utils";
import { getCalEventResponses } from "@calcom/features/bookings/lib/getCalEventResponses";
import { BookingSeatRepository } from "@calcom/features/bookings/repositories/BookingSeatRepository";
import { CreditService } from "@calcom/features/ee/billing/credit-service";
import { getBookerBaseUrl } from "@calcom/features/ee/organizations/lib/getBookerUrlServer";
import { isAttendeeAction } from "@calcom/features/ee/workflows/lib/actionHelperFunctions";
import { scheduleSmsOrFallbackEmail } from "@calcom/features/ee/workflows/lib/reminders/messageDispatcher";
+import { UrlShortenerFactory } from "@calcom/features/url-shortener/UrlShortenerFactory";
+import { DUB_SMS_DOMAIN, DUB_SMS_FOLDER_ID } from "@calcom/lib/constants";
import { getTranslation } from "@calcom/i18n/server";
import { getTimeFormatStringFromUserTimeFormat } from "@calcom/lib/timeFormat";
import prisma from "@calcom/prisma";
import { WorkflowActions, WorkflowMethods, WorkflowTemplates } from "@calcom/prisma/enums";
import { bookingMetadataSchema } from "@calcom/prisma/zod-utils";
-
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
import { getSenderId } from "../lib/alphanumericSenderIdSupport";
import type { PartialWorkflowReminder } from "../lib/getWorkflowReminders";
-import { select, getWorkflowRecipientEmail } from "../lib/getWorkflowReminders";
+import { getWorkflowRecipientEmail, select } from "../lib/getWorkflowReminders";
import type { VariablesType } from "../lib/reminders/templates/customTemplate";
import customTemplate from "../lib/reminders/templates/customTemplate";
import smsReminderTemplate from "../lib/reminders/templates/smsReminderTemplate";
@@ -141,8 +141,12 @@ export async function handler(req: NextRequest) {
}`,
};
+ const shortener = await UrlShortenerFactory.create({ userId, teamId });
const [{ shortLink: meetingUrl }, { shortLink: cancelLink }, { shortLink: rescheduleLink }] =
- await bulkShortenLinks([urls.meetingUrl, urls.cancelLink, urls.rescheduleLink]);
+ await shortener.shortenMany([urls.meetingUrl, urls.cancelLink, urls.rescheduleLink], {
+ domain: DUB_SMS_DOMAIN,
+ folderId: DUB_SMS_FOLDER_ID,
+ });
const variables: VariablesType = {
eventName: reminder.booking?.eventType?.title,
diff --git a/packages/features/ee/workflows/lib/reminders/smsReminderManager.ts b/packages/features/ee/workflows/lib/reminders/smsReminderManager.ts
index 66c1fa7a947..d7506ecc27a 100644
--- a/packages/features/ee/workflows/lib/reminders/smsReminderManager.ts
+++ b/packages/features/ee/workflows/lib/reminders/smsReminderManager.ts
@@ -195,7 +195,7 @@ const scheduleSMSReminderForEvt = async (
}
if (smsMessage) {
- smsMessage = await getSMSMessageWithVariables(smsMessage, evt, attendeeToBeUsedInSMS, action);
+ smsMessage = await getSMSMessageWithVariables(smsMessage, evt, attendeeToBeUsedInSMS, action, userId, teamId);
} else if (template === WorkflowTemplates.REMINDER) {
smsMessage =
smsReminderTemplate(
diff --git a/packages/features/ee/workflows/lib/reminders/utils.test.ts b/packages/features/ee/workflows/lib/reminders/utils.test.ts
new file mode 100644
index 00000000000..2aeb6bb0442
--- /dev/null
+++ b/packages/features/ee/workflows/lib/reminders/utils.test.ts
@@ -0,0 +1,533 @@
+import dayjs from "@calcom/dayjs";
+import { WorkflowActions, WorkflowTriggerEvents } from "@calcom/prisma/enums";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { AttendeeInBookingInfo, BookingInfo } from "../types";
+
+const mockShortenMany = vi.fn();
+vi.mock("@calcom/features/url-shortener/UrlShortenerFactory", () => ({
+ UrlShortenerFactory: {
+ create: async () => ({
+ shortenMany: (...args: unknown[]) => mockShortenMany(...args),
+ }),
+ },
+}));
+
+vi.mock("@calcom/lib/constants", () => ({
+ DUB_SMS_DOMAIN: "sms.example.com",
+ DUB_SMS_FOLDER_ID: "folder-123",
+ WEBSITE_URL: "https://app.cal.com",
+}));
+
+const mockCustomTemplate = vi.fn().mockReturnValue({ text: "Final SMS text", html: "<p>Final SMS text</p>" });
+const mockTransformResponses = vi.fn((responses) => responses);
+vi.mock("./templates/customTemplate", () => ({
+ default: (...args: unknown[]) => mockCustomTemplate(...args),
+ transformBookingResponsesToVariableFormat: (...args: unknown[]) => mockTransformResponses(...args),
+}));
+
+const mockGetWorkflowRecipientEmail = vi.fn();
+vi.mock("../../getWorkflowReminders", () => ({
+ getWorkflowRecipientEmail: (...args: unknown[]) => mockGetWorkflowRecipientEmail(...args),
+}));
+
+import { getAttendeeToBeUsedInSMS, getSMSMessageWithVariables, shouldUseTwilio } from "./utils";
+
+function buildMockAttendee(overrides: Partial<AttendeeInBookingInfo> = {}): AttendeeInBookingInfo {
+ return {
+ name: "Test Attendee",
+ firstName: "Test",
+ lastName: "Attendee",
+ email: "[email protected]",
+ phoneNumber: "+15551234567",
+ timeZone: "America/New_York",
+ language: { locale: "en" },
+ ...overrides,
+ };
+}
+
+function buildMockBookingInfo(overrides: Partial<BookingInfo> = {}): BookingInfo {
+ return {
+ uid: "booking-uid-123",
+ bookerUrl: "https://cal.example.com",
+ attendees: [buildMockAttendee()],
+ organizer: {
+ language: { locale: "en" },
+ name: "Test Organizer",
+ email: "[email protected]",
+ timeZone: "Europe/London",
+ timeFormat: "HH:mm" as BookingInfo["organizer"]["timeFormat"],
+ username: "organizer",
+ },
+ eventType: {
+ slug: "test-event",
+ },
+ startTime: "2025-06-15T10:00:00Z",
+ endTime: "2025-06-15T11:00:00Z",
+ title: "Test Event",
+ location: "https://meet.google.com/test",
+ additionalNotes: "Some notes",
+ responses: null,
+ metadata: { videoCallUrl: "https://meet.google.com/abc" },
+ cancellationReason: null,
+ rescheduleReason: null,
+ ...overrides,
+ };
+}
+
+describe("utils", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockShortenMany.mockResolvedValue([
+ { shortLink: "https://short.link/meet" },
+ { shortLink: "https://short.link/cancel" },
+ { shortLink: "https://short.link/reschedule" },
+ ]);
+ mockCustomTemplate.mockReturnValue({ text: "Final SMS text", html: "<p>Final SMS text</p>" });
+ mockGetWorkflowRecipientEmail.mockReturnValue("[email protected]");
+ });
+
+ describe("getSMSMessageWithVariables", () => {
+ describe("URL construction", () => {
+ it("builds meetingUrl from metadata videoCallUrl", async () => {
+ const evt = buildMockBookingInfo({ metadata: { videoCallUrl: "https://meet.google.com/abc" } });
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[0]).toBe("https://meet.google.com/abc");
+ });
+
+ it("uses empty string for meetingUrl when no videoCallUrl in metadata", async () => {
+ const evt = buildMockBookingInfo({ metadata: {} });
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[0]).toBe("");
+ });
+
+ it("builds cancelLink with cancelledBy param for attendee actions", async () => {
+ mockGetWorkflowRecipientEmail.mockReturnValue("[email protected]");
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[1]).toBe(
+ "https://cal.example.com/booking/booking-uid-123?cancel=true&[email protected]"
+ );
+ });
+
+ it("builds cancelLink without cancelledBy when recipientEmail is null", async () => {
+ mockGetWorkflowRecipientEmail.mockReturnValue(null);
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_NUMBER);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[1]).toBe("https://cal.example.com/booking/booking-uid-123?cancel=true");
+ });
+
+ it("builds rescheduleLink with rescheduledBy param", async () => {
+ mockGetWorkflowRecipientEmail.mockReturnValue("[email protected]");
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[2]).toBe(
+ "https://cal.example.com/reschedule/[email protected]"
+ );
+ });
+
+ it("builds rescheduleLink without rescheduledBy when recipientEmail is null", async () => {
+ mockGetWorkflowRecipientEmail.mockReturnValue(null);
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_NUMBER);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[2]).toBe("https://cal.example.com/reschedule/booking-uid-123");
+ });
+
+ it("falls back to WEBSITE_URL when bookerUrl is nullish", async () => {
+ const evt = buildMockBookingInfo({ bookerUrl: undefined as unknown as string });
+ const attendee = buildMockAttendee();
+ mockGetWorkflowRecipientEmail.mockReturnValue(null);
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_NUMBER);
+
+ const urls = mockShortenMany.mock.calls[0][0];
+ expect(urls[1]).toContain("https://app.cal.com/booking/");
+ expect(urls[2]).toContain("https://app.cal.com/reschedule/");
+ });
+ });
+
+ describe("URL shortening", () => {
+ it("calls shortenMany with all three URLs", async () => {
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ expect(mockShortenMany).toHaveBeenCalledTimes(1);
+ expect(mockShortenMany.mock.calls[0][0]).toHaveLength(3);
+ });
+
+ it("always passes domain and folderId options", async () => {
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ expect(mockShortenMany.mock.calls[0][1]).toEqual({
+ domain: "sms.example.com",
+ folderId: "folder-123",
+ });
+ });
+
+ it("uses shortened URLs in the variables passed to customTemplate", async () => {
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const variables = mockCustomTemplate.mock.calls[0][1];
+ expect(variables.meetingUrl).toBe("https://short.link/meet");
+ expect(variables.cancelLink).toBe("https://short.link/cancel");
+ expect(variables.rescheduleLink).toBe("https://short.link/reschedule");
+ });
+ });
+
+ describe("timezone selection", () => {
+ it("uses attendee timezone for SMS_ATTENDEE action", async () => {
+ const attendee = buildMockAttendee({ timeZone: "America/New_York" });
+ const evt = buildMockBookingInfo({
+ organizer: {
+ language: { locale: "en" },
+ name: "Org",
+ email: "[email protected]",
+ timeZone: "Europe/London",
+ },
+ });
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const variables = mockCustomTemplate.mock.calls[0][1];
+ expect(variables.timeZone).toBe("America/New_York");
+ });
+
+ it("uses organizer timezone for SMS_NUMBER action", async () => {
+ const attendee = buildMockAttendee({ timeZone: "America/New_York" });
+ const evt = buildMockBookingInfo({
+ organizer: {
+ language: { locale: "en" },
+ name: "Org",
+ email: "[email protected]",
+ timeZone: "Europe/London",
+ },
+ });
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_NUMBER);
+
+ const variables = mockCustomTemplate.mock.calls[0][1];
+ expect(variables.timeZone).toBe("Europe/London");
+ });
+ });
+
+ describe("variable assembly", () => {
+ it("includes all expected variable fields", async () => {
+ const evt = buildMockBookingInfo({
+ cancellationReason: "Too busy",
+ rescheduleReason: "Conflict",
+ });
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ const variables = mockCustomTemplate.mock.calls[0][1];
+ expect(variables).toMatchObject({
+ eventName: "Test Event",
+ organizerName: "Test Organizer",
+ attendeeName: "Test Attendee",
+ attendeeFirstName: "Test",
+ attendeeLastName: "Attendee",
+ attendeeEmail: "[email protected]",
+ location: "https://meet.google.com/test",
+ additionalNotes: "Some notes",
+ meetingUrl: "https://short.link/meet",
+ cancelLink: "https://short.link/cancel",
+ rescheduleLink: "https://short.link/reschedule",
+ cancelReason: "Too busy",
+ rescheduleReason: "Conflict",
+ });
+ expect(variables.eventDate).toBeDefined();
+ expect(variables.eventEndTime).toBeDefined();
+ expect(variables.timeZone).toBeDefined();
+ expect(variables.attendeeTimezone).toBeDefined();
+ expect(variables.eventTimeInAttendeeTimezone).toBeDefined();
+ expect(variables.eventEndTimeInAttendeeTimezone).toBeDefined();
+ });
+
+ it("attendeeTimezone always uses evt.attendees[0].timeZone", async () => {
+ const evt = buildMockBookingInfo({
+ attendees: [buildMockAttendee({ timeZone: "Asia/Tokyo" })],
+ });
+ const differentAttendee = buildMockAttendee({ timeZone: "US/Pacific" });
+
+ await getSMSMessageWithVariables("Hello", evt, differentAttendee, WorkflowActions.SMS_NUMBER);
+
+ const variables = mockCustomTemplate.mock.calls[0][1];
+ expect(variables.attendeeTimezone).toBe("Asia/Tokyo");
+ });
+ });
+
+ describe("locale and template rendering", () => {
+ it("uses attendee locale for SMS_ATTENDEE action", async () => {
+ const attendee = buildMockAttendee();
+ attendee.language = { locale: "fr" };
+ const evt = buildMockBookingInfo();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ expect(mockCustomTemplate.mock.calls[0][2]).toBe("fr");
+ });
+
+ it("uses organizer locale for non-attendee action", async () => {
+ const attendee = buildMockAttendee();
+ attendee.language = { locale: "fr" };
+ const evt = buildMockBookingInfo({
+ organizer: {
+ language: { locale: "de" },
+ name: "Org",
+ email: "[email protected]",
+ timeZone: "Europe/Berlin",
+ },
+ });
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_NUMBER);
+
+ expect(mockCustomTemplate.mock.calls[0][2]).toBe("de");
+ });
+
+ it("passes organizer timeFormat to customTemplate", async () => {
+ const evt = buildMockBookingInfo({
+ organizer: {
+ language: { locale: "en" },
+ name: "Org",
+ email: "[email protected]",
+ timeZone: "UTC",
+ timeFormat: "HH:mm" as BookingInfo["organizer"]["timeFormat"],
+ },
+ });
+ const attendee = buildMockAttendee();
+
+ await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_NUMBER);
+
+ expect(mockCustomTemplate.mock.calls[0][3]).toBe("HH:mm");
+ });
+
+ it("returns the text property from customTemplate result", async () => {
+ mockCustomTemplate.mockReturnValue({ text: "Your booking is confirmed", html: "" });
+ const evt = buildMockBookingInfo();
+ const attendee = buildMockAttendee();
+
+ const result = await getSMSMessageWithVariables("Hello", evt, attendee, WorkflowActions.SMS_ATTENDEE);
+
+ expect(result).toBe("Your booking is confirmed");
+ });
+ });
+ });
+
+ describe("getAttendeeToBeUsedInSMS", () => {
+ describe("SMS_ATTENDEE action", () => {
+ it("returns attendee matching responses email when reminderPhone is truthy", () => {
+ const matchingAttendee = buildMockAttendee({ email: "[email protected]", name: "Match" });
+ const firstAttendee = buildMockAttendee({ email: "[email protected]", name: "First" });
+ const evt = buildMockBookingInfo({
+ attendees: [firstAttendee, matchingAttendee],
+ responses: { email: { value: "[email protected]", label: "Email" } },
+ });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.SMS_ATTENDEE, evt, "+15551234567");
+
+ expect(result.name).toBe("Match");
+ });
+
+ it("falls back to first attendee when no attendee matches email", () => {
+ const firstAttendee = buildMockAttendee({ email: "[email protected]", name: "First" });
+ const evt = buildMockBookingInfo({
+ attendees: [firstAttendee],
+ responses: { email: { value: "[email protected]", label: "Email" } },
+ });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.SMS_ATTENDEE, evt, "+15551234567");
+
+ expect(result.name).toBe("First");
+ });
+
+ it("falls back to first attendee when reminderPhone is null", () => {
+ const firstAttendee = buildMockAttendee({ email: "[email protected]", name: "First" });
+ const matchAttendee = buildMockAttendee({ email: "[email protected]", name: "Match" });
+ const evt = buildMockBookingInfo({
+ attendees: [firstAttendee, matchAttendee],
+ responses: { email: { value: "[email protected]", label: "Email" } },
+ });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.SMS_ATTENDEE, evt, null);
+
+ expect(result.name).toBe("First");
+ });
+
+ it("falls back to first attendee when reminderPhone is empty string", () => {
+ const firstAttendee = buildMockAttendee({ email: "[email protected]", name: "First" });
+ const evt = buildMockBookingInfo({
+ attendees: [firstAttendee],
+ responses: { email: { value: "[email protected]", label: "Email" } },
+ });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.SMS_ATTENDEE, evt, "");
+
+ expect(result.name).toBe("First");
+ });
+
+ it("falls back to first attendee when responses is null", () => {
+ const firstAttendee = buildMockAttendee({ name: "First" });
+ const evt = buildMockBookingInfo({
+ attendees: [firstAttendee],
+ responses: null,
+ });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.SMS_ATTENDEE, evt, "+15551234567");
+
+ expect(result.name).toBe("First");
+ });
+ });
+
+ describe("non-attendee actions", () => {
+ it("returns first attendee for SMS_NUMBER action", () => {
+ const firstAttendee = buildMockAttendee({ name: "First" });
+ const secondAttendee = buildMockAttendee({ name: "Second" });
+ const evt = buildMockBookingInfo({ attendees: [firstAttendee, secondAttendee] });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.SMS_NUMBER, evt, "+15551234567");
+
+ expect(result.name).toBe("First");
+ });
+
+ it("returns first attendee for EMAIL_HOST action", () => {
+ const firstAttendee = buildMockAttendee({ name: "First" });
+ const evt = buildMockBookingInfo({ attendees: [firstAttendee] });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.EMAIL_HOST, evt, null);
+
+ expect(result.name).toBe("First");
+ });
+
+ it("returns first attendee for WHATSAPP_NUMBER action", () => {
+ const firstAttendee = buildMockAttendee({ name: "First" });
+ const evt = buildMockBookingInfo({ attendees: [firstAttendee] });
+
+ const result = getAttendeeToBeUsedInSMS(WorkflowActions.WHATSAPP_NUMBER, evt, "+15551234567");
+
+ expect(result.name).toBe("First");
+ });
+ });
+ });
+
+ describe("shouldUseTwilio", () => {
+ describe("immediate trigger events", () => {
+ const immediateEvents = [
+ WorkflowTriggerEvents.NEW_EVENT,
+ WorkflowTriggerEvents.EVENT_CANCELLED,
+ WorkflowTriggerEvents.RESCHEDULE_EVENT,
+ WorkflowTriggerEvents.BOOKING_NO_SHOW_UPDATED,
+ WorkflowTriggerEvents.BOOKING_PAID,
+ WorkflowTriggerEvents.BOOKING_PAYMENT_INITIATED,
+ WorkflowTriggerEvents.BOOKING_REJECTED,
+ WorkflowTriggerEvents.BOOKING_REQUESTED,
+ WorkflowTriggerEvents.FORM_SUBMITTED,
+ WorkflowTriggerEvents.FORM_SUBMITTED_NO_EVENT,
+ ];
+
+ immediateEvents.forEach((trigger) => {
+ it(`returns true for ${trigger}`, () => {
+ expect(shouldUseTwilio(trigger, null)).toBe(true);
+ });
+ });
+
+ it("returns true for immediate triggers regardless of scheduledDate", () => {
+ expect(shouldUseTwilio(WorkflowTriggerEvents.NEW_EVENT, dayjs().add(5, "hour"))).toBe(true);
+ });
+ });
+
+ describe("BEFORE_EVENT / AFTER_EVENT", () => {
+ it("returns true when scheduledDate is 30min from now", () => {
+ const scheduledDate = dayjs().add(30, "minute");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(true);
+ });
+
+ it("returns true when scheduledDate is 1hr from now", () => {
+ const scheduledDate = dayjs().add(1, "hour");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(true);
+ });
+
+ it("returns false when scheduledDate is null", () => {
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, null)).toBe(false);
+ });
+
+ it("returns false when scheduledDate is 10min from now (too close)", () => {
+ const scheduledDate = dayjs().add(10, "minute");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(false);
+ });
+
+ it("returns false when scheduledDate is 3hr from now (beyond 2hr window)", () => {
+ const scheduledDate = dayjs().add(3, "hour");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(false);
+ });
+
+ it("returns false at exactly 15min boundary", () => {
+ const scheduledDate = dayjs().add(15, "minute");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(false);
+ });
+
+ it("returns true at 16min from now", () => {
+ const scheduledDate = dayjs().add(16, "minute");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(true);
+ });
+
+ it("returns false at 2hr+1min from now", () => {
+ const scheduledDate = dayjs().add(2, "hour").add(1, "minute");
+ expect(shouldUseTwilio(WorkflowTriggerEvents.BEFORE_EVENT, scheduledDate)).toBe(false);
+ });
+
+ it("works the same for AFTER_EVENT trigger", () => {
+ const withinWindow = dayjs().add(30, "minute");
+ const outsideWindow = dayjs().add(3, "hour");
+
+ expect(shouldUseTwilio(WorkflowTriggerEvents.AFTER_EVENT, withinWindow)).toBe(true);
+ expect(shouldUseTwilio(WorkflowTriggerEvents.AFTER_EVENT, outsideWindow)).toBe(false);
+ });
+ });
+
+ describe("other triggers", () => {
+ it("returns false for AFTER_HOSTS_CAL_VIDEO_NO_SHOW", () => {
+ expect(
+ shouldUseTwilio(WorkflowTriggerEvents.AFTER_HOSTS_CAL_VIDEO_NO_SHOW, dayjs().add(30, "minute"))
+ ).toBe(false);
+ });
+
+ it("returns false for AFTER_GUESTS_CAL_VIDEO_NO_SHOW", () => {
+ expect(
+ shouldUseTwilio(WorkflowTriggerEvents.AFTER_GUESTS_CAL_VIDEO_NO_SHOW, dayjs().add(30, "minute"))
+ ).toBe(false);
+ });
+ });
+ });
+});
diff --git a/packages/features/ee/workflows/lib/reminders/utils.ts b/packages/features/ee/workflows/lib/reminders/utils.ts
index 259d5bb3e17..c6f522ef7b9 100644
--- a/packages/features/ee/workflows/lib/reminders/utils.ts
+++ b/packages/features/ee/workflows/lib/reminders/utils.ts
@@ -1,46 +1,21 @@
import dayjs from "@calcom/dayjs";
-import { dub } from "@calcom/features/auth/lib/dub";
-import { WEBSITE_URL } from "@calcom/lib/constants";
+import { UrlShortenerFactory } from "@calcom/features/url-shortener/UrlShortenerFactory";
+import { DUB_SMS_DOMAIN, DUB_SMS_FOLDER_ID, WEBSITE_URL } from "@calcom/lib/constants";
import { WorkflowActions, WorkflowTriggerEvents } from "@calcom/prisma/enums";
import { bookingMetadataSchema } from "@calcom/prisma/zod-utils";
-
import { IMMEDIATE_WORKFLOW_TRIGGER_EVENTS } from "../constants";
import { getWorkflowRecipientEmail } from "../getWorkflowReminders";
import type { AttendeeInBookingInfo, BookingInfo } from "../types";
import type { VariablesType } from "./templates/customTemplate";
import customTemplate, { transformBookingResponsesToVariableFormat } from "./templates/customTemplate";
-export const bulkShortenLinks = async (links: string[]) => {
- if (!process.env.DUB_API_KEY) {
- return links.map((link) => ({ shortLink: link }));
- }
-
- const linksToShorten = links.filter((link) => link);
- const results = await dub.links.createMany(
- linksToShorten.map((link) => ({
- domain: "sms.cal.com",
- url: link,
- folderId: "fold_wx3NZDKQYbLDbncSubeMu0ss",
- }))
- );
- return links.map((link) => {
- const createdLink = results.find(
- (result): result is Extract<typeof result, { url: string }> =>
- !("error" in result) && result.url === link
- );
- if (createdLink) {
- return { shortLink: createdLink.shortLink };
- } else {
- return { shortLink: link };
- }
- });
-};
-
export const getSMSMessageWithVariables = async (
smsMessage: string,
evt: BookingInfo,
attendeeToBeUsedInSMS: AttendeeInBookingInfo,
- action: WorkflowActions
+ action: WorkflowActions,
+ userId?: number | null,
+ teamId?: number | null
) => {
const recipientEmail = getWorkflowRecipientEmail({
action,
@@ -56,8 +31,12 @@ export const getSMSMessageWithVariables = async (
}`,
};
+ const shortener = await UrlShortenerFactory.create({ userId, teamId });
const [{ shortLink: meetingUrl }, { shortLink: cancelLink }, { shortLink: rescheduleLink }] =
- await bulkShortenLinks([urls.meetingUrl, urls.cancelLink, urls.rescheduleLink]);
+ await shortener.shortenMany([urls.meetingUrl, urls.cancelLink, urls.rescheduleLink], {
+ domain: DUB_SMS_DOMAIN,
+ folderId: DUB_SMS_FOLDER_ID,
+ });
const timeZone =
action === WorkflowActions.SMS_ATTENDEE || action === WorkflowActions.WHATSAPP_ATTENDEE
diff --git a/packages/features/flags/config.ts b/packages/features/flags/config.ts
index 2430d39ba05..512e2e87f28 100644
--- a/packages/features/flags/config.ts
+++ b/packages/features/flags/config.ts
@@ -39,6 +39,7 @@ export type AppFlags = {
"active-user-billing": boolean;
"sidebar-tips": boolean;
"signup-watchlist-review": boolean;
+ "sink-shortener": boolean;
};
export type TeamFeatures = Record<keyof AppFlags, boolean>;
diff --git a/packages/features/url-shortener/IUrlShortenerProvider.ts b/packages/features/url-shortener/IUrlShortenerProvider.ts
new file mode 100644
index 00000000000..d9e8068c1cc
--- /dev/null
+++ b/packages/features/url-shortener/IUrlShortenerProvider.ts
@@ -0,0 +1,12 @@
+export interface ShortenResult {
+ shortLink: string;
+}
+
+export interface ShortenOptions {
+ domain?: string;
+ folderId?: string;
+}
+
+export interface IUrlShortenerProvider {
+ shortenMany(urls: string[], options?: ShortenOptions): Promise<ShortenResult[]>;
+}
diff --git a/packages/features/url-shortener/UrlShortenerFactory.ts b/packages/features/url-shortener/UrlShortenerFactory.ts
new file mode 100644
index 00000000000..373c0d8d37d
--- /dev/null
+++ b/packages/features/url-shortener/UrlShortenerFactory.ts
@@ -0,0 +1,43 @@
+import { FeaturesRepository } from "@calcom/features/flags/features.repository";
+import prisma from "@calcom/prisma";
+
+import type { IUrlShortenerProvider } from "./IUrlShortenerProvider";
+import { DubShortener } from "./providers/DubShortener";
+import { NoopShortener } from "./providers/NoopShortener";
+import { SinkClient } from "./providers/SinkClient";
+import { SinkShortener } from "./providers/SinkShortener";
+
+export class UrlShortenerFactory {
+ static async create({
+ userId,
+ teamId,
+ }: { userId?: number | null; teamId?: number | null } = {}): Promise<IUrlShortenerProvider> {
+ if (SinkShortener.isConfigured()) {
+ const featuresRepository = new FeaturesRepository(prisma);
+
+ const globallyEnabled = await featuresRepository.checkIfFeatureIsEnabledGlobally("sink-shortener");
+ if (globallyEnabled) {
+ return new SinkShortener(new SinkClient());
+ }
+
+ if (userId) {
+ const useSink = await featuresRepository.checkIfUserHasFeature(userId, "sink-shortener");
+ if (useSink) {
+ return new SinkShortener(new SinkClient());
+ }
+ }
+
+ if (teamId) {
+ const useSink = await featuresRepository.checkIfTeamHasFeature(teamId, "sink-shortener");
+ if (useSink) {
+ return new SinkShortener(new SinkClient());
+ }
+ }
+ }
+
+ if (DubShortener.isConfigured()) {
+ return new DubShortener();
+ }
+ return new NoopShortener();
+ }
+}
diff --git a/packages/features/url-shortener/__tests__/DubShortener.test.ts b/packages/features/url-shortener/__tests__/DubShortener.test.ts
new file mode 100644
index 00000000000..fa1128477c4
--- /dev/null
+++ b/packages/features/url-shortener/__tests__/DubShortener.test.ts
@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@calcom/lib/logger", () => ({
+ default: {
+ getSubLogger: () => ({
+ debug: vi.fn(),
+ error: vi.fn(),
+ warn: vi.fn(),
+ }),
+ },
+}));
+
+const mockCreateMany = vi.fn();
+vi.mock("@calcom/features/auth/lib/dub", () => ({
+ dub: {
+ links: {
+ createMany: (...args: unknown[]) => mockCreateMany(...args),
+ },
+ },
+}));
+
+import { DubShortener } from "../providers/DubShortener";
+
+describe("DubShortener", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.unstubAllEnvs();
+ vi.stubEnv("DUB_API_KEY", "");
+ });
+
+ describe("isConfigured", () => {
+ it("returns true when DUB_API_KEY is set", () => {
+ vi.stubEnv("DUB_API_KEY", "test-key");
+ expect(DubShortener.isConfigured()).toBe(true);
+ });
+
+ it("returns false when DUB_API_KEY is not set", () => {
+ expect(DubShortener.isConfigured()).toBe(false);
+ });
+ });
+
+ describe("shortenMany", () => {
+ it("returns shortened links", async () => {
+ mockCreateMany.mockResolvedValue([
+ { url: "https://example.com", shortLink: "https://sms.cal.com/abc" },
+ ]);
+ const shortener = new DubShortener();
+
+ const result = await shortener.shortenMany(["https://example.com"]);
+
+ expect(result).toEqual([{ shortLink: "https://sms.cal.com/abc" }]);
+ });
+
+ it("passes domain and folderId options", async () => {
+ mockCreateMany.mockResolvedValue([{ url: "https://example.com", shortLink: "https://custom.com/abc" }]);
+ const shortener = new DubShortener();
+
+ await shortener.shortenMany(["https://example.com"], {
+ domain: "custom.com",
+ folderId: "folder123",
+ });
+
+ expect(mockCreateMany).toHaveBeenCalledWith([
+ {
+ domain: "custom.com",
+ url: "https://example.com",
+ folderId: "folder123",
+ },
+ ]);
+ });
+
+ it("handles multiple URLs", async () => {
+ mockCreateMany.mockResolvedValue([
+ { url: "https://example1.com", shortLink: "https://sms.cal.com/abc" },
+ { url: "https://example2.com", shortLink: "https://sms.cal.com/def" },
+ ]);
+ const shortener = new DubShortener();
+
+ const result = await shortener.shortenMany(["https://example1.com", "https://example2.com"]);
+
+ expect(result).toEqual([
+ { shortLink: "https://sms.cal.com/abc" },
+ { shortLink: "https://sms.cal.com/def" },
+ ]);
+ });
+
+ it("filters empty URLs before sending to Dub", async () => {
+ mockCreateMany.mockResolvedValue([
+ { url: "https://example.com", shortLink: "https://sms.cal.com/abc" },
+ ]);
+ const shortener = new DubShortener();
+
+ await shortener.shortenMany(["", "https://example.com", ""]);
+
+ expect(mockCreateMany).toHaveBeenCalledWith([
+ {
+ domain: undefined,
+ url: "https://example.com",
+ folderId: undefined,
+ },
+ ]);
+ });
+
+ it("returns original URL when Dub returns error result", async () => {
+ mockCreateMany.mockResolvedValue([
+ { url: "https://example1.com", shortLink: "https://sms.cal.com/abc" },
+ { error: "rate_limit_exceeded" },
+ { url: "https://example3.com", shortLink: "https://sms.cal.com/def" },
+ ]);
+ const shortener = new DubShortener();
+
+ const result = await shortener.shortenMany([
+ "https://example1.com",
+ "https://example2.com",
+ "https://example3.com",
+ ]);
+
+ expect(result).toEqual([
+ { shortLink: "https://sms.cal.com/abc" },
+ { shortLink: "https://example2.com" },
+ { shortLink: "https://sms.cal.com/def" },
+ ]);
+ });
+
+ it("returns original URLs on API error", async () => {
+ mockCreateMany.mockRejectedValue(new Error("Dub API error"));
+ const shortener = new DubShortener();
+
+ const result = await shortener.shortenMany(["https://example1.com", "https://example2.com"]);
+
+ expect(result).toEqual([{ shortLink: "https://example1.com" }, { shortLink: "https://example2.com" }]);
+ });
+
+ it("handles mixed empty and valid URLs correctly", async () => {
+ mockCreateMany.mockResolvedValue([
+ { url: "https://example.com", shortLink: "https://sms.cal.com/abc" },
+ ]);
+ const shortener = new DubShortener();
+
+ const result = await shortener.shortenMany(["", "https://example.com", ""]);
+
+ expect(result).toEqual([
+ { shortLink: "" },
+ { shortLink: "https://sms.cal.com/abc" },
+ { shortLink: "" },
+ ]);
+ });
+ });
+});
diff --git a/packages/features/url-shortener/__tests__/NoopShortener.test.ts b/packages/features/url-shortener/__tests__/NoopShortener.test.ts
new file mode 100644
index 00000000000..ad6022f7576
--- /dev/null
+++ b/packages/features/url-shortener/__tests__/NoopShortener.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { NoopShortener } from "../providers/NoopShortener";
+
+describe("NoopShortener", () => {
+ it("returns original URLs unchanged", async () => {
+ const shortener = new NoopShortener();
+
+ const result = await shortener.shortenMany(["https://example1.com", "https://example2.com"]);
+
+ expect(result).toEqual([{ shortLink: "https://example1.com" }, { shortLink: "https://example2.com" }]);
+ });
+
+ it("handles empty array", async () => {
+ const shortener = new NoopShortener();
+
+ const result = await shortener.shortenMany([]);
+
+ expect(result).toEqual([]);
+ });
+
+ it("handles empty strings", async () => {
+ const shortener = new NoopShortener();
+
+ const result = await shortener.shortenMany(["", "", ""]);
+
+ expect(result).toEqual([{ shortLink: "" }, { shortLink: "" }, { shortLink: "" }]);
+ });
+
+ it("ignores options parameter", async () => {
+ const shortener = new NoopShortener();
+
+ const result = await shortener.shortenMany(["https://example.com"], {
+ domain: "custom.com",
+ folderId: "folder123",
+ });
+
+ expect(result).toEqual([{ shortLink: "https://example.com" }]);
+ });
+});
diff --git a/packages/features/url-shortener/__tests__/SinkClient.test.ts b/packages/features/url-shortener/__tests__/SinkClient.test.ts
new file mode 100644
index 00000000000..93474600d57
--- /dev/null
+++ b/packages/features/url-shortener/__tests__/SinkClient.test.ts
@@ -0,0 +1,299 @@
+import type { Mock } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { SinkClient } from "../providers/SinkClient";
+
+const mockFetch = vi.fn() as Mock;
+global.fetch = mockFetch;
+
+vi.mock("@calcom/lib/logger", () => ({
+ default: {
+ getSubLogger: () => ({
+ debug: vi.fn(),
+ error: vi.fn(),
+ warn: vi.fn(),
+ }),
+ },
+}));
+
+describe("SinkClient", () => {
+ const mockSinkUrl = "https://sink.test.com";
+ const mockApiKey = "test-api-key";
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.unstubAllEnvs();
+ });
+
+ describe("createLink", () => {
+ beforeEach(() => {
+ vi.stubEnv("SINK_API_URL", mockSinkUrl);
+ vi.stubEnv("SINK_API_KEY", mockApiKey);
+ });
+
+ it("should successfully create a shortened link", async () => {
+ const mockResponse = {
+ link: {
+ id: "abc123",
+ url: "https://example.com",
+ slug: "xyz",
+ createdAt: "2024-01-01",
+ updatedAt: "2024-01-01",
+ views: 0,
+ },
+ shortLink: "https://sink.test.com/xyz",
+ };
+
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockResponse,
+ });
+
+ const testSink = new SinkClient();
+ const result = await testSink.createLink("https://example.com");
+
+ expect(result).toBe("https://sink.test.com/xyz");
+ expect(global.fetch).toHaveBeenCalledWith(
+ `${mockSinkUrl}/api/link/create`,
+ expect.objectContaining({
+ method: "POST",
+ headers: expect.objectContaining({
+ "Content-Type": "application/json",
+ Authorization: `Bearer ${mockApiKey}`,
+ }),
+ body: JSON.stringify({ url: "https://example.com" }),
+ })
+ );
+ });
+
+ it("should return null when Sink is not configured", async () => {
+ vi.stubEnv("SINK_API_URL", "");
+
+ const testSink = new SinkClient();
+ const result = await testSink.createLink("https://example.com");
+
+ expect(result).toBeNull();
+ expect(global.fetch).not.toHaveBeenCalled();
+ });
+
+ it("should return null on API error response", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: false,
+ status: 500,
+ text: async () => "Internal Server Error",
+ });
+
+ const testSink = new SinkClient();
+ const result = await testSink.createLink("https://example.com");
+
+ expect(result).toBeNull();
+ });
+
+ it("should return null on network error", async () => {
+ mockFetch.mockRejectedValueOnce(new Error("Network error"));
+
+ const testSink = new SinkClient();
+ const result = await testSink.createLink("https://example.com");
+
+ expect(result).toBeNull();
+ });
+
+ it("should pass options to the API", async () => {
+ const mockResponse = {
+ link: {
+ id: "abc123",
+ url: "https://example.com",
+ slug: "custom-slug",
+ comment: "Test comment",
+ createdAt: "2024-01-01",
+ updatedAt: "2024-01-01",
+ views: 0,
+ },
+ shortLink: "https://sink.test.com/custom-slug",
+ };
+
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockResponse,
+ });
+
+ const testSink = new SinkClient();
+ await testSink.createLink("https://example.com", {
+ slug: "custom-slug",
+ comment: "Test comment",
+ });
+
+ expect(global.fetch).toHaveBeenCalledWith(
+ `${mockSinkUrl}/api/link/create`,
+ expect.objectContaining({
+ body: JSON.stringify({
+ url: "https://example.com",
+ slug: "custom-slug",
+ comment: "Test comment",
+ }),
+ })
+ );
+ });
+ });
+
+ describe("createMany", () => {
+ beforeEach(() => {
+ vi.stubEnv("SINK_API_URL", mockSinkUrl);
+ vi.stubEnv("SINK_API_KEY", mockApiKey);
+ });
+
+ it("should successfully shorten multiple links", async () => {
+ const mockResponse = (url: string, index: number) => ({
+ link: {
+ id: `abc${index}`,
+ url,
+ slug: `xyz${index}`,
+ createdAt: "2024-01-01",
+ updatedAt: "2024-01-01",
+ views: 0,
+ },
+ shortLink: `https://sink.test.com/xyz${index}`,
+ });
+
+ mockFetch
+ .mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockResponse("https://example1.com", 1),
+ })
+ .mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockResponse("https://example2.com", 2),
+ })
+ .mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockResponse("https://example3.com", 3),
+ });
+
+ const testSink = new SinkClient();
+ const results = await testSink.createMany([
+ "https://example1.com",
+ "https://example2.com",
+ "https://example3.com",
+ ]);
+
+ expect(results).toEqual([
+ { url: "https://example1.com", shortLink: "https://sink.test.com/xyz1" },
+ { url: "https://example2.com", shortLink: "https://sink.test.com/xyz2" },
+ { url: "https://example3.com", shortLink: "https://sink.test.com/xyz3" },
+ ]);
+ expect(global.fetch).toHaveBeenCalledTimes(3);
+ });
+
+ it("should return original URLs when Sink is not configured", async () => {
+ vi.stubEnv("SINK_API_URL", "");
+
+ const testSink = new SinkClient();
+ const results = await testSink.createMany(["https://example1.com", "https://example2.com"]);
+
+ expect(results).toEqual([
+ { url: "https://example1.com", shortLink: null },
+ { url: "https://example2.com", shortLink: null },
+ ]);
+ expect(global.fetch).not.toHaveBeenCalled();
+ });
+
+ it("should handle empty URLs in the array", async () => {
+ const mockResponse = {
+ link: {
+ id: "abc123",
+ url: "https://example.com",
+ slug: "xyz",
+ createdAt: "2024-01-01",
+ updatedAt: "2024-01-01",
+ views: 0,
+ },
+ shortLink: "https://sink.test.com/xyz",
+ };
+
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockResponse,
+ });
+
+ const testSink = new SinkClient();
+ const results = await testSink.createMany(["", "https://example.com", ""]);
+
+ expect(results[0]).toEqual({ url: "", shortLink: null });
+ expect(results[1]).toEqual({ url: "https://example.com", shortLink: "https://sink.test.com/xyz" });
+ expect(results[2]).toEqual({ url: "", shortLink: null });
+ expect(global.fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it("should handle partial failures gracefully", async () => {
+ const mockSuccessResponse = {
+ link: {
+ id: "abc1",
+ url: "https://example1.com",
+ slug: "xyz1",
+ createdAt: "2024-01-01",
+ updatedAt: "2024-01-01",
+ views: 0,
+ },
+ shortLink: "https://sink.test.com/xyz1",
+ };
+
+ mockFetch
+ .mockResolvedValueOnce({
+ ok: true,
+ json: async () => mockSuccessResponse,
+ })
+ .mockRejectedValueOnce(new Error("Network error"))
+ .mockResolvedValueOnce({
+ ok: false,
+ status: 500,
+ text: async () => "Server error",
+ });
+
+ const testSink = new SinkClient();
+ const results = await testSink.createMany([
+ "https://example1.com",
+ "https://example2.com",
+ "https://example3.com",
+ ]);
+
+ expect(results).toEqual([
+ { url: "https://example1.com", shortLink: "https://sink.test.com/xyz1" },
+ { url: "https://example2.com", shortLink: null },
+ { url: "https://example3.com", shortLink: null },
+ ]);
+ });
+
+ it("should handle empty array", async () => {
+ const testSink = new SinkClient();
+ const results = await testSink.createMany([]);
+
+ expect(results).toEqual([]);
+ expect(global.fetch).not.toHaveBeenCalled();
+ });
+
+ it("should process all URLs in parallel", async () => {
+ const mockResponse = {
+ link: {
+ id: "abc",
+ url: "https://example.com",
+ slug: "xyz",
+ createdAt: "2024-01-01",
+ updatedAt: "2024-01-01",
+ views: 0,
+ },
+ shortLink: "https://sink.test.com/xyz",
+ };
+
+ mockFetch.mockResolvedValue({
+ ok: true,
+ json: async () => mockResponse,
+ });
+
+ const testSink = new SinkClient();
+ const urls = Array(10).fill("https://example.com");
+
+ await testSink.createMany(urls);
+
+ expect(global.fetch).toHaveBeenCalledTimes(10);
+ });
+ });
+});
diff --git a/packages/features/url-shortener/__tests__/SinkShortener.test.ts b/packages/features/url-shortener/__tests__/SinkShortener.test.ts
new file mode 100644
index 00000000000..49b7157ff98
--- /dev/null
+++ b/packages/features/url-shortener/__tests__/SinkShortener.test.ts
@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { SinkClient } from "../providers/SinkClient";
+import { SinkShortener } from "../providers/SinkShortener";
+
+vi.mock("@calcom/lib/logger", () => ({
+ default: {
+ getSubLogger: () => ({
+ debug: vi.fn(),
+ error: vi.fn(),
+ warn: vi.fn(),
+ }),
+ },
+}));
+
+function createMockClient(overrides: Partial<SinkClient> = {}): SinkClient {
+ return {
+ isConfigured: vi.fn().mockReturnValue(true),
+ createLink: vi.fn(),
+ createMany: vi.fn().mockResolvedValue([]),
+ ...overrides,
+ } as unknown as SinkClient;
+}
+
+describe("SinkShortener", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.unstubAllEnvs();
+ });
+
+ describe("isConfigured", () => {
+ it("returns true when both SINK_API_URL and SINK_API_KEY are set", () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ expect(SinkShortener.isConfigured()).toBe(true);
+ });
+
+ it("returns false when SINK_API_URL is missing", () => {
+ vi.stubEnv("SINK_API_URL", "");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ expect(SinkShortener.isConfigured()).toBe(false);
+ });
+
+ it("returns false when SINK_API_KEY is missing", () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "");
+ expect(SinkShortener.isConfigured()).toBe(false);
+ });
+ });
+
+ describe("shortenMany", () => {
+ it("returns shortened links from client", async () => {
+ const client = createMockClient({
+ createMany: vi
+ .fn()
+ .mockResolvedValue([{ url: "https://example.com", shortLink: "https://sink.test.com/abc" }]),
+ });
+ const shortener = new SinkShortener(client);
+
+ const result = await shortener.shortenMany(["https://example.com"]);
+
+ expect(result).toEqual([{ shortLink: "https://sink.test.com/abc" }]);
+ });
+
+ it("falls back to original URL when shortLink is null", async () => {
+ const client = createMockClient({
+ createMany: vi.fn().mockResolvedValue([{ url: "https://example.com", shortLink: null }]),
+ });
+ const shortener = new SinkShortener(client);
+
+ const result = await shortener.shortenMany(["https://example.com"]);
+
+ expect(result).toEqual([{ shortLink: "https://example.com" }]);
+ });
+
+ it("returns original URLs on client error", async () => {
+ const client = createMockClient({
+ createMany: vi.fn().mockRejectedValue(new Error("API error")),
+ });
+ const shortener = new SinkShortener(client);
+
+ const result = await shortener.shortenMany(["https://example1.com", "https://example2.com"]);
+
+ expect(result).toEqual([{ shortLink: "https://example1.com" }, { shortLink: "https://example2.com" }]);
+ });
+
+ it("ignores options parameter", async () => {
+ const mockCreateMany = vi
+ .fn()
+ .mockResolvedValue([{ url: "https://example.com", shortLink: "https://sink.test.com/abc" }]);
+ const client = createMockClient({ createMany: mockCreateMany });
+ const shortener = new SinkShortener(client);
+
+ await shortener.shortenMany(["https://example.com"], { domain: "custom.com", folderId: "folder123" });
+
+ expect(mockCreateMany).toHaveBeenCalledWith(["https://example.com"]);
+ });
+ });
+});
diff --git a/packages/features/url-shortener/__tests__/UrlShortenerFactory.test.ts b/packages/features/url-shortener/__tests__/UrlShortenerFactory.test.ts
new file mode 100644
index 00000000000..2006ce90b05
--- /dev/null
+++ b/packages/features/url-shortener/__tests__/UrlShortenerFactory.test.ts
@@ -0,0 +1,176 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@calcom/lib/logger", () => ({
+ default: {
+ getSubLogger: () => ({
+ debug: vi.fn(),
+ error: vi.fn(),
+ warn: vi.fn(),
+ }),
+ },
+}));
+
+vi.mock("@calcom/features/auth/lib/dub", () => ({
+ dub: {
+ links: {
+ createMany: vi.fn(),
+ },
+ },
+}));
+
+const mockCheckIfUserHasFeature = vi.fn();
+const mockCheckIfTeamHasFeature = vi.fn();
+const mockCheckIfFeatureIsEnabledGlobally = vi.fn();
+vi.mock("@calcom/features/flags/features.repository", () => ({
+ FeaturesRepository: class {
+ checkIfUserHasFeature = mockCheckIfUserHasFeature;
+ checkIfTeamHasFeature = mockCheckIfTeamHasFeature;
+ checkIfFeatureIsEnabledGlobally = mockCheckIfFeatureIsEnabledGlobally;
+ },
+}));
+
+vi.mock("@calcom/prisma", () => ({
+ default: {},
+}));
+
+import { DubShortener } from "../providers/DubShortener";
+import { NoopShortener } from "../providers/NoopShortener";
+import { SinkShortener } from "../providers/SinkShortener";
+import { UrlShortenerFactory } from "../UrlShortenerFactory";
+
+describe("UrlShortenerFactory", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.unstubAllEnvs();
+ vi.stubEnv("SINK_API_URL", "");
+ vi.stubEnv("SINK_API_KEY", "");
+ vi.stubEnv("DUB_API_KEY", "");
+ mockCheckIfUserHasFeature.mockResolvedValue(false);
+ mockCheckIfTeamHasFeature.mockResolvedValue(false);
+ mockCheckIfFeatureIsEnabledGlobally.mockResolvedValue(false);
+ });
+
+ describe("global feature flag", () => {
+ it("returns SinkShortener when globally enabled (no userId or teamId)", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ mockCheckIfFeatureIsEnabledGlobally.mockResolvedValue(true);
+
+ const provider = await UrlShortenerFactory.create();
+
+ expect(provider).toBeInstanceOf(SinkShortener);
+ expect(mockCheckIfUserHasFeature).not.toHaveBeenCalled();
+ expect(mockCheckIfTeamHasFeature).not.toHaveBeenCalled();
+ });
+
+ it("returns SinkShortener when globally enabled (skips user and team checks)", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ mockCheckIfFeatureIsEnabledGlobally.mockResolvedValue(true);
+
+ const provider = await UrlShortenerFactory.create({ userId: 1, teamId: 2 });
+
+ expect(provider).toBeInstanceOf(SinkShortener);
+ expect(mockCheckIfUserHasFeature).not.toHaveBeenCalled();
+ expect(mockCheckIfTeamHasFeature).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("user feature flag (global off)", () => {
+ it("returns SinkShortener when user has sink-shortener flag enabled", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ mockCheckIfUserHasFeature.mockResolvedValue(true);
+
+ const provider = await UrlShortenerFactory.create({ userId: 1 });
+
+ expect(provider).toBeInstanceOf(SinkShortener);
+ expect(mockCheckIfUserHasFeature).toHaveBeenCalledWith(1, "sink-shortener");
+ expect(mockCheckIfTeamHasFeature).not.toHaveBeenCalled();
+ });
+
+ it("skips user check when userId is null", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ vi.stubEnv("DUB_API_KEY", "dub-test-key");
+
+ await UrlShortenerFactory.create({ userId: null });
+
+ expect(mockCheckIfUserHasFeature).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("team feature flag (global off, user off)", () => {
+ it("returns SinkShortener when team has sink-shortener flag enabled", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ mockCheckIfTeamHasFeature.mockResolvedValue(true);
+
+ const provider = await UrlShortenerFactory.create({ teamId: 2 });
+
+ expect(provider).toBeInstanceOf(SinkShortener);
+ expect(mockCheckIfTeamHasFeature).toHaveBeenCalledWith(2, "sink-shortener");
+ });
+
+ it("falls back to team check when user check fails", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ mockCheckIfUserHasFeature.mockResolvedValue(false);
+ mockCheckIfTeamHasFeature.mockResolvedValue(true);
+
+ const provider = await UrlShortenerFactory.create({ userId: 1, teamId: 2 });
+
+ expect(provider).toBeInstanceOf(SinkShortener);
+ expect(mockCheckIfUserHasFeature).toHaveBeenCalledWith(1, "sink-shortener");
+ expect(mockCheckIfTeamHasFeature).toHaveBeenCalledWith(2, "sink-shortener");
+ });
+
+ it("returns DubShortener when both user and team flags are off", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ vi.stubEnv("DUB_API_KEY", "dub-test-key");
+
+ const provider = await UrlShortenerFactory.create({ userId: 1, teamId: 2 });
+
+ expect(provider).toBeInstanceOf(DubShortener);
+ });
+
+ it("skips team check when teamId is null", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("SINK_API_KEY", "test-key");
+ vi.stubEnv("DUB_API_KEY", "dub-test-key");
+
+ await UrlShortenerFactory.create({ teamId: null });
+
+ expect(mockCheckIfTeamHasFeature).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("Sink env vars not configured", () => {
+ it("returns DubShortener without checking any flags", async () => {
+ vi.stubEnv("DUB_API_KEY", "dub-test-key");
+
+ const provider = await UrlShortenerFactory.create({ userId: 1, teamId: 2 });
+
+ expect(provider).toBeInstanceOf(DubShortener);
+ expect(mockCheckIfUserHasFeature).not.toHaveBeenCalled();
+ expect(mockCheckIfTeamHasFeature).not.toHaveBeenCalled();
+ expect(mockCheckIfFeatureIsEnabledGlobally).not.toHaveBeenCalled();
+ });
+
+ it("returns NoopShortener when nothing is configured", async () => {
+ const provider = await UrlShortenerFactory.create();
+
+ expect(provider).toBeInstanceOf(NoopShortener);
+ });
+
+ it("returns DubShortener when Sink URL is set but key is missing", async () => {
+ vi.stubEnv("SINK_API_URL", "https://sink.test.com");
+ vi.stubEnv("DUB_API_KEY", "dub-test-key");
+
+ const provider = await UrlShortenerFactory.create({ userId: 1 });
+
+ expect(provider).toBeInstanceOf(DubShortener);
+ });
+ });
+});
diff --git a/packages/features/url-shortener/providers/DubShortener.ts b/packages/features/url-shortener/providers/DubShortener.ts
new file mode 100644
index 00000000000..6020529bb0d
--- /dev/null
+++ b/packages/features/url-shortener/providers/DubShortener.ts
@@ -0,0 +1,35 @@
+import { dub } from "@calcom/features/auth/lib/dub";
+import logger from "@calcom/lib/logger";
+import type { IUrlShortenerProvider, ShortenOptions, ShortenResult } from "../IUrlShortenerProvider";
+
+const log = logger.getSubLogger({ prefix: ["dub-shortener"] });
+
+export class DubShortener implements IUrlShortenerProvider {
+ static isConfigured(): boolean {
+ return Boolean(process.env.DUB_API_KEY);
+ }
+
+ async shortenMany(urls: string[], options?: ShortenOptions): Promise<ShortenResult[]> {
+ try {
+ const linksToShorten = urls.filter((link) => link);
+ const dubResults = await dub.links.createMany(
+ linksToShorten.map((url) => ({
+ domain: options?.domain,
+ url,
+ folderId: options?.folderId,
+ }))
+ );
+
+ return urls.map((url) => {
+ const createdLink = dubResults.find(
+ (result): result is Extract<typeof result, { url: string }> =>
+ !("error" in result) && result.url === url
+ );
+ return { shortLink: createdLink?.shortLink || url };
+ });
+ } catch (error) {
+ log.error("Dub shortening failed, returning original URLs", error);
+ return urls.map((url) => ({ shortLink: url }));
+ }
+ }
+}
diff --git a/packages/features/url-shortener/providers/NoopShortener.ts b/packages/features/url-shortener/providers/NoopShortener.ts
new file mode 100644
index 00000000000..68eb4873081
--- /dev/null
+++ b/packages/features/url-shortener/providers/NoopShortener.ts
@@ -0,0 +1,7 @@
+import type { IUrlShortenerProvider, ShortenOptions, ShortenResult } from "../IUrlShortenerProvider";
+
+export class NoopShortener implements IUrlShortenerProvider {
+ async shortenMany(urls: string[], _options?: ShortenOptions): Promise<ShortenResult[]> {
+ return urls.map((url) => ({ shortLink: url }));
+ }
+}
diff --git a/packages/features/url-shortener/providers/SinkClient.ts b/packages/features/url-shortener/providers/SinkClient.ts
new file mode 100644
index 00000000000..bbb6dc1f83e
--- /dev/null
+++ b/packages/features/url-shortener/providers/SinkClient.ts
@@ -0,0 +1,113 @@
+import logger from "@calcom/lib/logger";
+
+const log = logger.getSubLogger({ prefix: ["sink-url-shortener"] });
+
+interface SinkLinkCreateRequest {
+ url: string;
+ slug?: string;
+ comment?: string;
+ expiration?: string;
+ password?: string;
+ disable?: boolean;
+}
+
+interface SinkLinkResponse {
+ link: {
+ id: string;
+ url: string;
+ slug: string;
+ comment?: string;
+ createdAt: string;
+ updatedAt: string;
+ expiresAt?: string;
+ password?: string;
+ disabled?: boolean;
+ views: number;
+ };
+ shortLink: string;
+}
+
+export class SinkClient {
+ private baseUrl: string;
+ private apiKey?: string;
+
+ constructor() {
+ this.baseUrl = process.env.SINK_API_URL || "";
+ this.apiKey = process.env.SINK_API_KEY;
+ }
+
+ isConfigured(): boolean {
+ return Boolean(this.baseUrl && this.apiKey);
+ }
+
+ async createLink(url: string, options?: Partial<SinkLinkCreateRequest>): Promise<string | null> {
+ if (!this.isConfigured()) {
+ log.debug("Sink not configured, skipping link creation");
+ return null;
+ }
+
+ try {
+ const headers: Record<string, string> = {
+ "Content-Type": "application/json",
+ };
+
+ headers.Authorization = `Bearer ${this.apiKey}`;
+
+ const response = await fetch(`${this.baseUrl}/api/link/create`, {
+ method: "POST",
+ headers,
+ body: JSON.stringify({
+ url,
+ ...options,
+ }),
+ signal: AbortSignal.timeout(10_000),
+ });
+
+ if (!response.ok) {
+ const errorText = await response.text();
+ log.error(`Sink API error: ${response.status} - ${errorText}`);
+ return null;
+ }
+
+ const data = (await response.json()) as SinkLinkResponse;
+ return data.shortLink;
+ } catch (error) {
+ log.error("Failed to create Sink link", error);
+ return null;
+ }
+ }
+
+ async createMany(
+ links: string[],
+ options?: Partial<SinkLinkCreateRequest>
+ ): Promise<{ url: string; shortLink: string | null }[]> {
+ if (!this.isConfigured()) {
+ log.debug("Sink not configured, returning original links");
+ return links.map((url) => ({ url, shortLink: null }));
+ }
+
+ const promises = links.map(async (url) => {
+ if (!url) {
+ return { url, shortLink: null };
+ }
+
+ const shortLink = await this.createLink(url, options);
+ return { url, shortLink };
+ });
+
+ try {
+ const results = await Promise.allSettled(promises);
+ return results.map((result, index) => {
+ if (result.status === "fulfilled") {
+ return result.value;
+ } else {
+ log.error(`Failed to shorten link at index ${index}`, result.reason);
+ return { url: links[index], shortLink: null };
+ }
+ });
+ } catch (error) {
+ log.error("Failed to create multiple Sink links", error);
+ return links.map((url) => ({ url, shortLink: null }));
+ }
+ }
+}
diff --git a/packages/features/url-shortener/providers/SinkShortener.ts b/packages/features/url-shortener/providers/SinkShortener.ts
new file mode 100644
index 00000000000..a4397c50969
--- /dev/null
+++ b/packages/features/url-shortener/providers/SinkShortener.ts
@@ -0,0 +1,25 @@
+import logger from "@calcom/lib/logger";
+import type { IUrlShortenerProvider, ShortenOptions, ShortenResult } from "../IUrlShortenerProvider";
+import type { SinkClient } from "./SinkClient";
+
+const log = logger.getSubLogger({ prefix: ["sink-shortener"] });
+
+export class SinkShortener implements IUrlShortenerProvider {
+ constructor(private client: SinkClient) {}
+
+ static isConfigured(): boolean {
+ return Boolean(process.env.SINK_API_URL && process.env.SINK_API_KEY);
+ }
+
+ async shortenMany(urls: string[], _options?: ShortenOptions): Promise<ShortenResult[]> {
+ try {
+ const results = await this.client.createMany(urls);
+ return results.map((result) => ({
+ shortLink: result.shortLink || result.url,
+ }));
+ } catch (error) {
+ log.error("Sink shortening failed, returning original URLs", error);
+ return urls.map((url) => ({ shortLink: url }));
+ }
+ }
+}
diff --git a/packages/lib/constants.ts b/packages/lib/constants.ts
index ccdf4513415..beec49b7d20 100644
--- a/packages/lib/constants.ts
+++ b/packages/lib/constants.ts
@@ -231,6 +231,9 @@ export const URL_SCANNING_ENABLED =
export const IS_DUB_REFERRALS_ENABLED =
!!process.env.NEXT_PUBLIC_DUB_PROGRAM_ID && process.env.NEXT_PUBLIC_DUB_PROGRAM_ID !== "";
+export const DUB_SMS_DOMAIN = process.env.DUB_SMS_DOMAIN;
+export const DUB_SMS_FOLDER_ID = process.env.DUB_SMS_FOLDER_ID;
+
export const CAL_VIDEO_MEETING_LINK_FOR_TESTING = process.env.CAL_VIDEO_MEETING_LINK_FOR_TESTING;
export const IS_SMS_CREDITS_ENABLED =
diff --git a/packages/prisma/migrations/20260226000000_seed_sink_shortener_feature/migration.sql b/packages/prisma/migrations/20260226000000_seed_sink_shortener_feature/migration.sql
new file mode 100644
index 00000000000..0068c18f89a
--- /dev/null
+++ b/packages/prisma/migrations/20260226000000_seed_sink_shortener_feature/migration.sql
@@ -0,0 +1,4 @@
+INSERT INTO "Feature" ("slug", "enabled", "type", "description", "createdAt", "updatedAt")
+VALUES
+ ('sink-shortener', false, 'OPERATIONAL', 'Enable Sink URL shortener for SMS workflows', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+ON CONFLICT ("slug") DO NOTHING;