Skip changes in this commit

Intentionally empty to serve as placeholder for future updates.

Author: Prathamesh-chougale-17

apps/api/src/services/user-service.ts

@@ -7,6 +7,40 @@ import { AppError } from '../lib/http';
 const isUniqueViolation = (error: unknown): boolean =>
   typeof error === 'object' && error !== null && 'code' in error && error.code === '23505';
 
+const isBetterAuthConflict = (
+  error: unknown,
+  code: string,
+): error is {
+  statusCode?: number;
+  message?: string;
+  body?: {
+    code?: string;
+    message?: string;
+  };
+} => {
+  if (typeof error !== 'object' || error === null) {
+    return false;
+  }
+
+  const candidate = error as {
+    statusCode?: number;
+    message?: string;
+    body?: {
+      code?: string;
+      message?: string;
+    };
+  };
+
+  if (candidate.body?.code === code) {
+    return true;
+  }
+
+  const normalizedMessage = candidate.message?.toLowerCase();
+  const normalizedBodyMessage = candidate.body?.message?.toLowerCase();
+
+  return Boolean(normalizedMessage && normalizedBodyMessage && normalizedMessage.includes(normalizedBodyMessage));
+};
+
 const toIsoString = (value: Date | string): string =>
   value instanceof Date ? value.toISOString() : new Date(value).toISOString();
 
@@ -88,6 +122,17 @@ export class UserService {
         throw new AppError(409, 'CONFLICT', 'A pending invitation already exists for that email');
       }
 
+      if (
+        isBetterAuthConflict(error, 'USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION') ||
+        isBetterAuthConflict(error, 'USER_ALREADY_MEMBER_OF_ORGANIZATION')
+      ) {
+        throw new AppError(
+          409,
+          'CONFLICT',
+          error.body?.message ?? 'A pending invitation already exists for that email',
+        );
+      }
+
       throw error;
     }
   }

apps/api/src/tests/app.test.ts

@@ -64,14 +64,17 @@ const authContext: {
 };
 
 let currentAuthContext = authContext;
+const { createInvitationMock } = vi.hoisted(() => ({
+  createInvitationMock: vi.fn(async () => ({
+    id: 'a079fe59-bcec-4ceb-a07b-dc0a439e0d76',
+  })),
+}));
 
 vi.mock('@acme/auth', () => ({
   canManageMembers: (role: string | null | undefined) => role === 'owner' || role === 'admin',
   auth: {
     api: {
-      createInvitation: vi.fn(async () => ({
-        id: 'a079fe59-bcec-4ceb-a07b-dc0a439e0d76',
-      })),
+      createInvitation: createInvitationMock,
     },
   },
   resolveAuthContext: vi.fn(async (headers: Headers) =>
@@ -149,6 +152,10 @@ describe('api routes', () => {
   beforeEach(() => {
     repository = createRepository();
     currentAuthContext = authContext;
+    createInvitationMock.mockReset();
+    createInvitationMock.mockResolvedValue({
+      id: 'a079fe59-bcec-4ceb-a07b-dc0a439e0d76',
+    });
   });
 
   it('returns health metadata', async () => {
@@ -263,6 +270,45 @@ describe('api routes', () => {
     expect(body.data.invitationId).toBe('a079fe59-bcec-4ceb-a07b-dc0a439e0d76');
   });
 
+  it('returns a conflict when Better Auth reports an existing invitation', async () => {
+    createInvitationMock.mockRejectedValueOnce({
+      message: 'User is already invited to this organization',
+      statusCode: 400,
+      body: {
+        code: 'USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION',
+        message: 'User is already invited to this organization',
+      },
+    });
+
+    const app = createApp({
+      env: loadApiEnv({
+        DATABASE_URL: 'postgres://postgres:postgres@localhost:5432/acme_platform',
+      }),
+      usersRepository: repository,
+    });
+
+    const response = await app.request('/api/v1/invitations', {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        cookie: 'session=valid',
+      },
+      body: JSON.stringify({
+        email: 'grace@example.com',
+        role: 'member',
+      }),
+    });
+    const body = (await response.json()) as ApiResponse<never>;
+
+    expect(response.status).toBe(409);
+    expect(body.success).toBe(false);
+    if (body.success) {
+      throw new Error('Expected an error response');
+    }
+    expect(body.error.code).toBe('CONFLICT');
+    expect(body.error.message).toBe('User is already invited to this organization');
+  });
+
   it('hides invitation data for member-only workspaces', async () => {
     currentAuthContext = {
       ...authContext,

apps/web/components/users-workspace.tsx

@@ -30,6 +30,7 @@ import {
 import type { AuthRole, CreateInvitationInput, CurrentUserDto } from '@acme/shared';
 
 import { authClient } from '@/lib/auth-client';
+import { ApiClientError } from '@/lib/api-client';
 import { useCreateInvitationMutation, useUsersWorkspaceQuery } from '@/lib/queries';
 
 const getErrorMessage = (error: unknown) =>
@@ -93,13 +94,26 @@ export function UsersWorkspace({
   const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
     event.preventDefault();
     setNotice(null);
+    const submittedInvite = { ...inviteForm };
 
     try {
-      await createInvitationMutation.mutateAsync(inviteForm);
+      await createInvitationMutation.mutateAsync(submittedInvite);
       setInviteForm({ email: '', role: 'member' });
-      setNotice(`Invitation queued for ${inviteForm.email}`);
-    } catch {
-      // Mutation state drives the error message UI.
+      setNotice(`Invitation queued for ${submittedInvite.email}`);
+    } catch (error) {
+      if (error instanceof ApiClientError && error.code === 'REQUEST_TIMEOUT') {
+        const refreshedWorkspace = await workspaceQuery.refetch();
+        const invitationWasCreated = refreshedWorkspace.data?.invitations.some(
+          (invitation) => invitation.email === submittedInvite.email,
+        );
+
+        if (invitationWasCreated) {
+          setInviteForm({ email: '', role: 'member' });
+          setNotice(
+            `Invitation queued for ${submittedInvite.email}. Delivery took longer than the browser wait, but the pending invite was created successfully.`,
+          );
+        }
+      }
     }
   };
 

apps/web/lib/api-client.ts

@@ -23,6 +23,7 @@ export class ApiClientError extends Error {
 }
 
 const REQUEST_TIMEOUT_MS = 8_000;
+const INVITATION_REQUEST_TIMEOUT_MS = 20_000;
 
 const parseApiResponse = async (response: Response): Promise<ApiResponse<unknown> | undefined> => {
   const text = await response.text();
@@ -38,9 +39,18 @@ const parseApiResponse = async (response: Response): Promise<ApiResponse<unknown
   }
 };
 
-const request = async <T>(path: string, init: RequestInit, schema: z.ZodType<T>): Promise<T> => {
+const request = async <T>(
+  path: string,
+  init: RequestInit,
+  schema: z.ZodType<T>,
+  options?: {
+    timeoutMs?: number;
+    timeoutMessage?: string;
+  },
+): Promise<T> => {
+  const timeoutMs = options?.timeoutMs ?? REQUEST_TIMEOUT_MS;
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
 
   try {
     const response = await fetch(path, {
@@ -74,7 +84,8 @@ const request = async <T>(path: string, init: RequestInit, schema: z.ZodType<T>)
   } catch (error) {
     if (error instanceof DOMException && error.name === 'AbortError') {
       throw new ApiClientError(
-        `Request timed out after ${REQUEST_TIMEOUT_MS / 1000}s. Confirm the web API proxy is configured and the upstream API is reachable.`,
+        options?.timeoutMessage ??
+          `Request timed out after ${timeoutMs / 1000}s. Confirm the web API proxy is configured and the upstream API is reachable.`,
         504,
         'REQUEST_TIMEOUT',
       );
@@ -101,5 +112,10 @@ export const apiClient = {
       z.object({
         invitationId: z.uuid(),
       }),
+      {
+        timeoutMs: INVITATION_REQUEST_TIMEOUT_MS,
+        timeoutMessage:
+          'Invitation delivery is taking longer than expected. We will check whether the invite was still created before showing an error.',
+      },
     ),
 };