fix: merge conflicts

packages/lib/server-only/user/create-user.ts

@@ -8,6 +8,7 @@ import { IdentityProvider, TeamMemberInviteStatus } from '@documenso/prisma/clie
 import { IS_BILLING_ENABLED } from '../../constants/app';
 import { SALT_ROUNDS } from '../../constants/auth';
 import { AppError, AppErrorCode } from '../../errors/app-error';
+import { buildLogger } from '../../utils/logger';
 
 export interface CreateUserOptions {
   name: string;
@@ -27,7 +28,7 @@ export const createUser = async ({ name, email, password, signature, url }: Crea
   });
 
   if (userExists) {
-    throw new Error('User already exists');
+    throw new AppError(AppErrorCode.ALREADY_EXISTS);
   }
 
   if (url) {
@@ -38,11 +39,10 @@ export const createUser = async ({ name, email, password, signature, url }: Crea
     });
 
     if (urlExists) {
-      throw new AppError(
-        AppErrorCode.PROFILE_URL_TAKEN,
-        'Profile username is taken',
-        'The profile username is already taken',
-      );
+      throw new AppError(AppErrorCode.PROFILE_URL_TAKEN, {
+        message: 'Profile username is taken',
+        userMessage: 'The profile username is already taken',
+      });
     }
   }
 
@@ -135,6 +135,18 @@ export const createUser = async ({ name, email, password, signature, url }: Crea
       return await getStripeCustomerByUser(user).then((session) => session.user);
     } catch (err) {
       console.error(err);
+
+      const error = AppError.parseError(err);
+
+      const logger = buildLogger();
+
+      logger.error(error, {
+        method: 'createUser',
+        context: {
+          appError: AppError.toJSON(error),
+          userId: user.id,
+        },
+      });
     }
   }
 

packages/lib/server-only/user/delete-user.ts

@@ -1,6 +1,7 @@
 import { prisma } from '@documenso/prisma';
 import { DocumentStatus } from '@documenso/prisma/client';
 
+import { AppError, AppErrorCode } from '../../errors/app-error';
 import { deletedAccountServiceAccount } from './service-accounts/deleted-account';
 
 export type DeleteUserOptions = {
@@ -15,7 +16,9 @@ export const deleteUser = async ({ id }: DeleteUserOptions) => {
   });
 
   if (!user) {
-    throw new Error(`User with ID ${id} not found`);
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: `User with ID ${id} not found`,
+    });
   }
 
   const serviceAccount = await deletedAccountServiceAccount();

packages/lib/server-only/user/disable-user.ts

@@ -0,0 +1,69 @@
+import { AppError } from '@documenso/lib/errors/app-error';
+import { prisma } from '@documenso/prisma';
+
+export type DisableUserOptions = {
+  id: number;
+};
+
+export const disableUser = async ({ id }: DisableUserOptions) => {
+  const user = await prisma.user.findFirst({
+    where: {
+      id,
+    },
+    include: {
+      apiTokens: true,
+      webhooks: true,
+      passkeys: true,
+      verificationTokens: true,
+      passwordResetTokens: true,
+    },
+  });
+
+  if (!user) {
+    throw new AppError('There was an error disabling the user');
+  }
+
+  try {
+    await prisma.$transaction(async (tx) => {
+      await tx.user.update({
+        where: { id },
+        data: { disabled: true },
+      });
+
+      await tx.apiToken.updateMany({
+        where: { userId: id },
+        data: {
+          expires: new Date(),
+        },
+      });
+
+      await tx.webhook.updateMany({
+        where: { userId: id },
+        data: {
+          enabled: false,
+        },
+      });
+
+      await tx.verificationToken.updateMany({
+        where: { userId: id },
+        data: {
+          expires: new Date(),
+        },
+      });
+
+      await tx.passwordResetToken.updateMany({
+        where: { userId: id },
+        data: {
+          expiry: new Date(),
+        },
+      });
+
+      await tx.passkey.deleteMany({
+        where: { userId: id },
+      });
+    });
+  } catch (error) {
+    console.error('Error disabling user', error);
+    throw error;
+  }
+};

packages/lib/server-only/user/enable-user.ts

@@ -0,0 +1,27 @@
+import { AppError } from '@documenso/lib/errors/app-error';
+import { prisma } from '@documenso/prisma';
+
+export type EnableUserOptions = {
+  id: number;
+};
+
+export const enableUser = async ({ id }: EnableUserOptions) => {
+  const user = await prisma.user.findFirst({
+    where: {
+      id,
+    },
+  });
+
+  if (!user) {
+    throw new AppError('There was an error enabling the user');
+  }
+
+  await prisma.user.update({
+    where: {
+      id,
+    },
+    data: {
+      disabled: false,
+    },
+  });
+};

packages/lib/server-only/user/find-user-security-audit-logs.ts

@@ -1,7 +1,8 @@
-import type { FindResultSet } from '@documenso/lib/types/find-result-set';
 import { prisma } from '@documenso/prisma';
 import type { UserSecurityAuditLog, UserSecurityAuditLogType } from '@documenso/prisma/client';
 
+import type { FindResultResponse } from '../../types/search-params';
+
 export type FindUserSecurityAuditLogsOptions = {
   userId: number;
   type?: UserSecurityAuditLogType;
@@ -48,5 +49,5 @@ export const findUserSecurityAuditLogs = async ({
     currentPage: Math.max(page, 1),
     perPage,
     totalPages: Math.ceil(count / perPage),
-  } satisfies FindResultSet<typeof data>;
+  } satisfies FindResultResponse<typeof data>;
 };

packages/lib/server-only/user/get-all-users.ts

@@ -34,8 +34,8 @@ export const findUsers = async ({
   const [users, count] = await Promise.all([
     prisma.user.findMany({
       include: {
-        Subscription: true,
-        Document: {
+        subscriptions: true,
+        documents: {
           select: {
             id: true,
           },

packages/lib/server-only/user/get-user-public-profile.ts

@@ -26,7 +26,7 @@ export const getUserPublicProfile = async ({
   });
 
   if (!user) {
-    throw new AppError(AppErrorCode.NOT_FOUND, 'User not found');
+    throw new AppError(AppErrorCode.NOT_FOUND, { message: 'User not found' });
   }
 
   // Create and return the public profile.
@@ -39,7 +39,7 @@ export const getUserPublicProfile = async ({
     });
 
     if (!profile) {
-      throw new AppError(AppErrorCode.NOT_FOUND, 'Failed to create public profile');
+      throw new AppError(AppErrorCode.NOT_FOUND, { message: 'Failed to create public profile' });
     }
 
     return {

packages/lib/server-only/user/reset-password.ts

@@ -4,6 +4,7 @@ import { prisma } from '@documenso/prisma';
 import { UserSecurityAuditLogType } from '@documenso/prisma/client';
 
 import { SALT_ROUNDS } from '../../constants/auth';
+import { AppError, AppErrorCode } from '../../errors/app-error';
 import type { RequestMetadata } from '../../universal/extract-request-metadata';
 import { sendResetPassword } from '../auth/send-reset-password';
 
@@ -15,7 +16,7 @@ export type ResetPasswordOptions = {
 
 export const resetPassword = async ({ token, password, requestMetadata }: ResetPasswordOptions) => {
   if (!token) {
-    throw new Error('Invalid token provided. Please try again.');
+    throw new AppError('INVALID_TOKEN');
   }
 
   const foundToken = await prisma.passwordResetToken.findFirst({
@@ -23,24 +24,24 @@ export const resetPassword = async ({ token, password, requestMetadata }: ResetP
       token,
     },
     include: {
-      User: true,
+      user: true,
     },
   });
 
   if (!foundToken) {
-    throw new Error('Invalid token provided. Please try again.');
+    throw new AppError('INVALID_TOKEN');
   }
 
   const now = new Date();
 
   if (now > foundToken.expiry) {
-    throw new Error('Token has expired. Please try again.');
+    throw new AppError(AppErrorCode.EXPIRED_CODE);
   }
 
-  const isSamePassword = await compare(password, foundToken.User.password || '');
+  const isSamePassword = await compare(password, foundToken.user.password || '');
 
   if (isSamePassword) {
-    throw new Error('Your new password cannot be the same as your old password.');
+    throw new AppError('SAME_PASSWORD');
   }
 
   const hashedPassword = await hash(password, SALT_ROUNDS);

packages/lib/server-only/user/update-password.ts

@@ -5,6 +5,8 @@ import type { RequestMetadata } from '@documenso/lib/universal/extract-request-m
 import { prisma } from '@documenso/prisma';
 import { UserSecurityAuditLogType } from '@documenso/prisma/client';
 
+import { AppError } from '../../errors/app-error';
+
 export type UpdatePasswordOptions = {
   userId: number;
   password: string;
@@ -26,18 +28,18 @@ export const updatePassword = async ({
   });
 
   if (!user.password) {
-    throw new Error('User has no password');
+    throw new AppError('NO_PASSWORD');
   }
 
   const isCurrentPasswordValid = await compare(currentPassword, user.password);
   if (!isCurrentPasswordValid) {
-    throw new Error('Current password is incorrect.');
+    throw new AppError('INCORRECT_PASSWORD');
   }
 
   // Compare the new password with the old password
   const isSamePassword = await compare(password, user.password);
   if (isSamePassword) {
-    throw new Error('Your new password cannot be the same as your old password.');
+    throw new AppError('SAME_PASSWORD');
   }
 
   const hashedNewPassword = await hash(password, SALT_ROUNDS);

packages/lib/server-only/user/update-public-profile.ts

@@ -13,7 +13,7 @@ export type UpdatePublicProfileOptions = {
 
 export const updatePublicProfile = async ({ userId, data }: UpdatePublicProfileOptions) => {
   if (Object.values(data).length === 0) {
-    throw new AppError(AppErrorCode.INVALID_BODY, 'Missing data to update');
+    throw new AppError(AppErrorCode.INVALID_BODY, { message: 'Missing data to update' });
   }
 
   const { url, bio, enabled } = data;
@@ -25,13 +25,15 @@ export const updatePublicProfile = async ({ userId, data }: UpdatePublicProfileO
   });
 
   if (!user) {
-    throw new AppError(AppErrorCode.NOT_FOUND, 'User not found');
+    throw new AppError(AppErrorCode.NOT_FOUND, { message: 'User not found' });
   }
 
   const finalUrl = url ?? user.url;
 
   if (!finalUrl && enabled) {
-    throw new AppError(AppErrorCode.INVALID_REQUEST, 'Cannot enable a profile without a URL');
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Cannot enable a profile without a URL',
+    });
   }
 
   if (url) {
@@ -57,7 +59,9 @@ export const updatePublicProfile = async ({ userId, data }: UpdatePublicProfileO
     });
 
     if (isUrlTakenByAnotherUser || isUrlTakenByAnotherTeam) {
-      throw new AppError(AppErrorCode.PROFILE_URL_TAKEN, 'The profile username is already taken');
+      throw new AppError(AppErrorCode.PROFILE_URL_TAKEN, {
+        message: 'The profile username is already taken',
+      });
     }
   }