fix: surface invite-email send failures instead of swallowing them

public/locales/en/common.json

@@ -162,7 +162,8 @@
     "invalid_cron_expression": "Invalid cron expression",
     "currency_conversion_failed": "Failed to convert currencies",
     "recurrence_delete_failed": "Failed to delete recurrence",
-    "recurrence_update_failed": "Failed to update recurrence"
+    "recurrence_update_failed": "Failed to update recurrence",
+    "invite_email_failed": "Failed to send invite email. Check the SMTP configuration."
   },
   "bank_transactions": {
     "choose_bank_provider": "Choose bank provider",

src/components/AddExpense/SelectUserOrGroup.tsx

@@ -5,11 +5,13 @@
 import { useTranslation } from 'next-i18next';
 import Image from 'next/image';
 import React, { useCallback } from 'react';
+import { toast } from 'sonner';
 import { z } from 'zod';
 
 import { useAddExpenseStore } from '~/store/addStore';
 import { api } from '~/utils/api';
 import { deserializeDefaultSplit } from '~/lib/defaultSplit';
+import { getInviteErrorToastKey, isInviteEmailSendFailed } from '~/lib/error/invite';
 
 import { EntityAvatar } from '../ui/avatar';
 import { Button } from '../ui/button';
@@ -48,13 +50,46 @@
   const onAddEmailClick = useCallback(
     (invite = false) => {
       if (isEmail.success) {
+        const email = nameOrEmail;
+        const removePendingParticipant = () => {
+          const pendingParticipant = useAddExpenseStore
+            .getState()
+            .participants.find((participant) => -1 === participant.id);
+          if (email === pendingParticipant?.email) {
+            removeParticipant(-1);
+          }
+        };
+        const addParticipant = (user: User) => {
+          removePendingParticipant();
+          addOrUpdateParticipant(user);
+          if (email === useAddExpenseStore.getState().nameOrEmail) {
+            setNameOrEmail('');
+          }
+        };
+
         addFriendMutation.mutate(
-          { email: nameOrEmail, sendInviteEmail: invite },
+          { email, sendInviteEmail: invite },
           {
-            onSuccess: (user) => {
-              removeParticipant(-1);
-              addOrUpdateParticipant(user);
-              setNameOrEmail('');
+            onSuccess: addParticipant,
+            onError: (err) => {
+              const appErrorCode = err.data?.appErrorCode;
+              toast.error(t(getInviteErrorToastKey(appErrorCode)));
+
+              // The friend row already exists whenever this router throws, so retry the participant-add.
+              if (isInviteEmailSendFailed(appErrorCode)) {
+                addFriendMutation.mutate(
+                  { email, sendInviteEmail: false },
+                  {
+                    onSuccess: addParticipant,
+                    onError: () => {
+                      removePendingParticipant();
+                      toast.error(t('errors.add_member_failed'));
+                    },
+                  },
+                );
+              } else {
+                removePendingParticipant();
+              }
             },
           },
         );
@@ -81,6 +116,7 @@
       addOrUpdateParticipant,
       setNameOrEmail,
       removeParticipant,
+      t,
     ],
   );
 
@@ -105,6 +141,7 @@
     [setGroup, setParticipants, setNameOrEmail],
   );
 
+  const handleAddEmailClickTrue = useCallback(() => onAddEmailClick(true), [onAddEmailClick]);
   const handleAddEmailClickFalse = useCallback(() => onAddEmailClick(false), [onAddEmailClick]);
 
   if (group) {
@@ -149,7 +186,7 @@
               className="mt-4 text-cyan-500 hover:text-cyan-500"
               variant="outline"
               disabled={!isEmail.success}
-              onClick={handleAddEmailClickFalse}
+              onClick={handleAddEmailClickTrue}
             >
               <SendIcon className="mr-2 h-4 w-4" />
               {t('expense_details.add_expense_details.select_user_or_group.send_invite')}
@@ -174,7 +211,7 @@
               <button
                 key={f.id}
                 className="flex w-full items-center justify-between border-b border-gray-900 py-4"
                 onClick={() => handleFriendClick(f)}
               >
                 <div className="flex min-w-0 items-center gap-4">
                   <EntityAvatar entity={f} size={35} />

src/components/group/AddMembers.tsx

@@ -9,6 +9,7 @@ import { z } from 'zod';
 
 import { Button } from '~/components/ui/button';
 import { AppDrawer } from '~/components/ui/drawer';
+import { getInviteErrorToastKey, isInviteEmailSendFailed } from '~/lib/error/invite';
 import { api } from '~/utils/api';
 
 import { EntityAvatar } from '../ui/avatar';
@@ -87,11 +88,27 @@ const AddMembers: React.FC<{
 
   function onAddEmailClick(invite = false) {
     if (isEmail.success) {
+      const email = inputValue.toLowerCase();
+      const addUserToGroup = (user: { id: number }) => onSave({ ...userIds, [user.id]: true });
+
       addFriendMutation.mutate(
-        { email: inputValue.toLowerCase(), sendInviteEmail: invite },
+        { email, sendInviteEmail: invite },
         {
-          onSuccess: (user) => {
-            onSave({ ...userIds, [user.id]: true });
+          onSuccess: addUserToGroup,
+          onError: (err) => {
+            const appErrorCode = err.data?.appErrorCode;
+            toast.error(t(getInviteErrorToastKey(appErrorCode)));
+
+            // The friend row already exists whenever this router throws, so retry the group-add.
+            if (isInviteEmailSendFailed(appErrorCode)) {
+              addFriendMutation.mutate(
+                { email, sendInviteEmail: false },
+                {
+                  onSuccess: addUserToGroup,
+                  onError: () => toast.error(t('errors.add_member_failed')),
+                },
+              );
+            }
           },
         },
       );

src/lib/error/invite.ts

@@ -0,0 +1,15 @@
+export const InviteErrorCode = {
+  INVITES_DISABLED: 'INVITES_DISABLED',
+  INVITE_RATE_LIMITED: 'INVITE_RATE_LIMITED',
+  INVITE_EMAIL_SEND_FAILED: 'INVITE_EMAIL_SEND_FAILED',
+} as const;
+
+export const isInviteEmailSendFailed = (appErrorCode: unknown): boolean =>
+  InviteErrorCode.INVITE_EMAIL_SEND_FAILED === appErrorCode;
+
+export const getInviteErrorToastKey = (
+  appErrorCode: string | null | undefined,
+): 'errors.invite_email_failed' | 'errors.add_member_failed' =>
+  InviteErrorCode.INVITE_EMAIL_SEND_FAILED === appErrorCode
+    ? 'errors.invite_email_failed'
+    : 'errors.add_member_failed';

src/lib/inviteCooldown.ts

@@ -0,0 +1,27 @@
+const INVITE_COOLDOWN_MS = 60_000;
+const lastInviteAtByUserPair = new Map<string, number>();
+let nextCleanupAt = 0;
+
+export const claimInviteCooldown = (
+  inviteeId: number,
+  inviterId: number,
+  now = Date.now(),
+): boolean => {
+  const userPair = `${inviteeId}:${inviterId}`;
+  const lastInviteAt = lastInviteAtByUserPair.get(userPair);
+  if (undefined !== lastInviteAt && now - lastInviteAt < INVITE_COOLDOWN_MS) {
+    return false;
+  }
+
+  if (now >= nextCleanupAt) {
+    lastInviteAtByUserPair.forEach((inviteAt, pair) => {
+      if (now - inviteAt >= INVITE_COOLDOWN_MS) {
+        lastInviteAtByUserPair.delete(pair);
+      }
+    });
+    nextCleanupAt = now + INVITE_COOLDOWN_MS;
+  }
+
+  lastInviteAtByUserPair.set(userPair, now);
+  return true;
+};

src/lib/utils.ts

@@ -4,3 +4,11 @@ import { twMerge } from 'tailwind-merge';
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
+
+export const escapeHtml = (value: string): string =>
+  value
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');

src/server/api/appError.ts

@@ -0,0 +1,12 @@
+export class AppError extends Error {
+  readonly code: string;
+
+  constructor(code: string, message: string) {
+    super(message);
+    this.name = 'AppError';
+    this.code = code;
+  }
+}
+
+export const getAppErrorCode = (cause: unknown): string | null =>
+  cause instanceof AppError ? cause.code : null;

src/server/api/routers/user.ts

@@ -8,7 +8,10 @@ import {
   serializeDefaultSplit,
   toSortedFriendPair,
 } from '~/lib/defaultSplit';
+import { claimInviteCooldown } from '~/lib/inviteCooldown';
+import { InviteErrorCode } from '~/lib/error/invite';
 import { simplifyDebts } from '~/lib/simplify';
+import { AppError } from '~/server/api/appError';
 import { createTRPCRouter, protectedProcedure } from '~/server/api/trpc';
 import { db } from '~/server/db';
 import { sendFeedbackEmail, sendInviteEmail } from '~/server/mailer';
@@ -25,6 +28,14 @@ import {
   importUserBalanceFromSplitWise,
 } from '../services/splitService';
 
+const throwInviteError = (
+  code: 'PRECONDITION_FAILED' | 'TOO_MANY_REQUESTS' | 'INTERNAL_SERVER_ERROR',
+  inviteErrorCode: (typeof InviteErrorCode)[keyof typeof InviteErrorCode],
+  message: string,
+): never => {
+  throw new TRPCError({ code, message, cause: new AppError(inviteErrorCode, message) });
+};
+
 export const userRouter = createTRPCRouter({
   me: protectedProcedure.query(({ ctx }) => ctx.session.user),
 
@@ -58,27 +69,47 @@ export const userRouter = createTRPCRouter({
   inviteFriend: protectedProcedure
     .input(z.object({ email: z.string(), sendInviteEmail: z.boolean().optional() }))
     .mutation(async ({ input, ctx: { session } }) => {
-      const friend = await db.user.findUnique({
-        where: {
-          email: input.email,
-        },
-      });
-
-      if (friend) {
-        return friend;
-      }
-
-      const user = await db.user.create({
-        data: {
+      // Upsert avoids a find-then-create race where two concurrent invites for the same brand-new email both miss the lookup and hit the unique constraint.
+      const user = await db.user.upsert({
+        where: { email: input.email },
+        update: {},
+        create: {
           email: input.email,
           name: input.email.split('@')[0],
         },
       });
 
-      if (input.sendInviteEmail) {
-        sendInviteEmail(input.email, session.user.name ?? session.user.email ?? '').catch((err) => {
-          console.error('Error sending invite email', err);
-        });
+      // Only a just-created or not-yet-verified user should get an invite email.
+      if (input.sendInviteEmail && !user.emailVerified) {
+        if (!env.ENABLE_SENDING_INVITES) {
+          throwInviteError(
+            'PRECONDITION_FAILED',
+            InviteErrorCode.INVITES_DISABLED,
+            'Invite emails are disabled on this server.',
+          );
+        }
+
+        if (!claimInviteCooldown(user.id, session.user.id)) {
+          throwInviteError(
+            'TOO_MANY_REQUESTS',
+            InviteErrorCode.INVITE_RATE_LIMITED,
+            'Please wait before re-sending an invite to this address.',
+          );
+        }
+
+        let sent = false;
+        try {
+          sent = await sendInviteEmail(input.email, session.user.name ?? session.user.email ?? '');
+        } catch (err) {
+          console.error('Error sending invite email to user', user.id, err);
+        }
+        if (!sent) {
+          throwInviteError(
+            'INTERNAL_SERVER_ERROR',
+            InviteErrorCode.INVITE_EMAIL_SEND_FAILED,
+            'Failed to send invite email. Check your SMTP configuration.',
+          );
+        }
       }
 
       return user;

src/server/api/trpc.ts

@@ -13,6 +13,7 @@ import { type Session } from 'next-auth';
 import superjson from 'superjson';
 import { ZodError, z } from 'zod';
 
+import { getAppErrorCode } from '~/server/api/appError';
 import { getServerAuthSession } from '~/server/auth';
 import { db } from '~/server/db';
 
@@ -76,6 +77,7 @@ const t = initTRPC.context<typeof createTRPCContext>().create({
       data: {
         ...shape.data,
         zodError: error.cause instanceof ZodError ? error.cause.flatten() : null,
+        appErrorCode: getAppErrorCode(error.cause),
       },
     };
   },
@@ -119,7 +121,7 @@ export const protectedProcedure = t.procedure.use(({ ctx, next }) => {
 
   return next({
     ctx: {
-      // infers the `session` as non-nullable
+      // Infers the `session` as non-nullable
       session: { ...ctx.session, user: ctx.session.user },
     },
   });

src/server/mailer.ts

@@ -2,6 +2,7 @@ import { type User } from 'next-auth';
 import nodemailer, { type Transporter } from 'nodemailer';
 
 import { env } from '~/env';
+import { escapeHtml } from '~/lib/utils';
 
 import { sendToDiscord } from './service-notification';
 
@@ -29,6 +30,9 @@ const getTransporter = () => {
   const transport = {
     ...mailServerConfig,
     secure: 465 === mailServerConfig.port,
+    connectionTimeout: 10_000,
+    greetingTimeout: 10_000,
+    socketTimeout: 30_000,
   };
 
   transporter = nodemailer.createTransport(transport);
@@ -61,14 +65,14 @@ export async function sendInviteEmail(email: string, name: string) {
 
   if ('development' === env.NODE_ENV) {
     console.log('Sending invite email', email, name);
-    return;
+    return true;
   }
 
   const subject = 'Invitation to SplitPro';
   const text = `Hey,\n\nYou have been invited to SplitPro by ${name}. It's a completely open source free alternative to splitwise. You can sign in to SplitPro by clicking the below URL:\n${env.NEXTAUTH_URL}\n\nThanks,\nSplitPro Team`;
-  const html = `<p>Hey,</p> <p>You have been invited to SplitPro by ${name}. It's a completely open source free alternative to splitwise. You can sign in to SplitPro by clicking the below URL:</p><p><a href="${env.NEXTAUTH_URL}">Sign in to ${host}</a></p><br><p>Thanks,<br/>SplitPro Team</p>`;
+  const html = `<p>Hey,</p> <p>You have been invited to SplitPro by ${escapeHtml(name)}. It's a completely open source free alternative to splitwise. You can sign in to SplitPro by clicking the below URL:</p><p><a href="${env.NEXTAUTH_URL}">Sign in to ${host}</a></p><br><p>Thanks,<br/>SplitPro Team</p>`;
 
-  await sendMail(email, subject, text, html);
+  return await sendMail(email, subject, text, html);
 }
 
 export async function sendFeedbackEmail(feedback: string, user: User) {
@@ -110,13 +114,17 @@ async function sendMail(
     }
   } catch (error) {
     console.log('Error sending email', error);
-    await sendToDiscord(
-      `Error sending email: ${
-        error instanceof Error
-          ? `error.message: ${error.message}\nerror.stack: ${error.stack}`
-          : 'Unknown error'
-      }`,
-    );
+    await Promise.resolve(
+      sendToDiscord(
+        `Error sending email: ${
+          error instanceof Error
+            ? `error.message: ${error.message}\nerror.stack: ${error.stack}`
+            : 'Unknown error'
+        }`,
+      ),
+    ).catch((notificationError: unknown) => {
+      console.error('Failed to report email error to Discord', notificationError);
+    });
   }
 
   return false;

src/server/service-notification.ts

@@ -16,6 +16,7 @@ export async function sendToDiscord(message: string) {
       'Content-Type': 'application/json',
     },
     body: JSON.stringify({ content: message }),
+    signal: AbortSignal.timeout(5_000),
   });
 
   if (response.ok) {