Function redeemInvite

packages/web/src/app/invite/actions.ts:75–162

(inviteId: string)

// eslint-disable-next-line authz/require-auth-wrapper -- runs pre-org-membership; uses getAuthenticatedUser() directly since withAuth requires a user-to-org link this call is establishing
export const redeemInvite = async (inviteId: string): Promise<{ success: boolean; } | ServiceError> => sew(async () => {
    const authResult = await getAuthenticatedUser();
    if (!authResult) {
        return notAuthenticated();
    }

    const { user } = authResult;

    const invite = await __unsafePrisma.invite.findUnique({
        where: {
            id: inviteId,
        },
        include: {
            org: true,
        }
    });

    if (!invite) {
        return notFound();
    }

    const failAuditCallback = async (error: string) => {
        await createAudit({
            action: "user.invite_accept_failed",
            actor: {
                id: user.id,
                type: "user"
            },
            target: {
                id: inviteId,
                type: "invite"
            },
            orgId: invite.org.id,
            metadata: {
                message: error
            }
        });
    };

    const hasAvailability = await orgHasAvailability(invite.org.id);
    if (!hasAvailability) {
        await failAuditCallback("Organization is at max capacity");
        return {
            statusCode: StatusCodes.BAD_REQUEST,
            errorCode: ErrorCode.ORG_SEAT_COUNT_REACHED,
            message: "Organization is at max capacity",
        } satisfies ServiceError;
    }

    // Check if the user is the recipient of the invite
    if (user.email !== invite.recipientEmail) {
        await failAuditCallback("User is not the recipient of the invite");
        return notFound();
    }

    const addUserToOrgRes = await addUserToOrganization(user.id, invite.orgId);
    if (isServiceError(addUserToOrgRes)) {
        await failAuditCallback(addUserToOrgRes.message);