Merge branch 'feat/refresh' into feat/completed-share-link

packages/lib/next-auth/auth-options.ts

@@ -89,7 +89,7 @@ export const NEXT_AUTH_OPTIONS: AuthOptions = {
       };
     },
 
-    async session({ token, session }) {
+    session({ token, session }) {
       if (token && token.email) {
         return {
           ...session,

packages/lib/next-auth/get-server-session.ts

@@ -1,9 +1,6 @@
 import { GetServerSidePropsContext, NextApiRequest, NextApiResponse } from 'next';
-import { headers } from 'next/headers';
-import { NextRequest } from 'next/server';
 
 import { getServerSession as getNextAuthServerSession } from 'next-auth';
-import { getToken } from 'next-auth/jwt';
 
 import { prisma } from '@documenso/prisma';
 
@@ -30,18 +27,6 @@ export const getServerSession = async ({ req, res }: GetServerSessionOptions) =>
   return user;
 };
 
-export const getServerComponentToken = async () => {
-  const requestHeaders = Object.fromEntries(headers().entries());
-
-  const req = new NextRequest('http://example.com', {
-    headers: requestHeaders,
-  });
-
-  const token = await getToken({
-    req,
-  });
-};
-
 export const getServerComponentSession = async () => {
   const session = await getNextAuthServerSession(NEXT_AUTH_OPTIONS);
 

packages/lib/server-only/document/complete-document-with-token.ts

@@ -87,6 +87,6 @@ export const completeDocumentWithToken = async ({
 
   if (documents.count > 0) {
     console.log('sealing document');
-    sealDocument({ documentId: document.id });
+    await sealDocument({ documentId: document.id });
   }
 };

packages/lib/server-only/document/find-documents.ts

@@ -1,13 +1,15 @@
+import { match } from 'ts-pattern';
+
 import { prisma } from '@documenso/prisma';
-import { Document, DocumentStatus, Prisma } from '@documenso/prisma/client';
-import { DocumentWithReciepient } from '@documenso/prisma/types/document-with-recipient';
+import { Document, Prisma, SigningStatus } from '@documenso/prisma/client';
+import { ExtendedDocumentStatus } from '@documenso/prisma/types/extended-document-status';
 
 import { FindResultSet } from '../../types/find-result-set';
 
 export interface FindDocumentsOptions {
   userId: number;
   term?: string;
-  status?: DocumentStatus;
+  status?: ExtendedDocumentStatus;
   page?: number;
   perPage?: number;
   orderBy?: {
@@ -19,29 +21,102 @@ export interface FindDocumentsOptions {
 export const findDocuments = async ({
   userId,
   term,
-  status,
+  status = ExtendedDocumentStatus.ALL,
   page = 1,
   perPage = 10,
   orderBy,
-}: FindDocumentsOptions): Promise<FindResultSet<DocumentWithReciepient>> => {
+}: FindDocumentsOptions) => {
+  const user = await prisma.user.findFirstOrThrow({
+    where: {
+      id: userId,
+    },
+  });
+
   const orderByColumn = orderBy?.column ?? 'created';
   const orderByDirection = orderBy?.direction ?? 'desc';
 
-  const filters: Prisma.DocumentWhereInput = {
-    status,
-    userId,
-  };
+  const termFilters = !term
+    ? undefined
+    : ({
+        title: {
+          contains: term,
+          mode: 'insensitive',
+        },
+      } as const);
 
-  if (term) {
-    filters.title = {
-      contains: term,
-      mode: 'insensitive',
-    };
-  }
+  const filters = match<ExtendedDocumentStatus, Prisma.DocumentWhereInput>(status)
+    .with(ExtendedDocumentStatus.ALL, () => ({
+      OR: [
+        {
+          userId,
+        },
+        {
+          status: {
+            not: ExtendedDocumentStatus.DRAFT,
+          },
+          Recipient: {
+            some: {
+              email: user.email,
+            },
+          },
+        },
+      ],
+    }))
+    .with(ExtendedDocumentStatus.INBOX, () => ({
+      status: {
+        not: ExtendedDocumentStatus.DRAFT,
+      },
+      Recipient: {
+        some: {
+          email: user.email,
+          signingStatus: SigningStatus.NOT_SIGNED,
+        },
+      },
+    }))
+    .with(ExtendedDocumentStatus.DRAFT, () => ({
+      userId,
+      status: ExtendedDocumentStatus.DRAFT,
+    }))
+    .with(ExtendedDocumentStatus.PENDING, () => ({
+      OR: [
+        {
+          userId,
+          status: ExtendedDocumentStatus.PENDING,
+        },
+        {
+          status: ExtendedDocumentStatus.PENDING,
+
+          Recipient: {
+            some: {
+              email: user.email,
+              signingStatus: SigningStatus.SIGNED,
+            },
+          },
+        },
+      ],
+    }))
+    .with(ExtendedDocumentStatus.COMPLETED, () => ({
+      OR: [
+        {
+          userId,
+          status: ExtendedDocumentStatus.COMPLETED,
+        },
+        {
+          status: ExtendedDocumentStatus.COMPLETED,
+          Recipient: {
+            some: {
+              email: user.email,
+            },
+          },
+        },
+      ],
+    }))
+    .exhaustive();
 
   const [data, count] = await Promise.all([
     prisma.document.findMany({
       where: {
+        ...termFilters,
         ...filters,
       },
       skip: Math.max(page - 1, 0) * perPage,
@@ -50,21 +125,37 @@ export const findDocuments = async ({
         [orderByColumn]: orderByDirection,
       },
       include: {
+        User: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
         Recipient: true,
       },
     }),
     prisma.document.count({
       where: {
+        ...termFilters,
         ...filters,
       },
     }),
   ]);
 
+  const maskedData = data.map((doc) => ({
+    ...doc,
+    Recipient: doc.Recipient.map((recipient) => ({
+      ...recipient,
+      token: recipient.email === user.email ? recipient.token : '',
+    })),
+  }));
+
   return {
-    data,
+    data: maskedData,
     count,
     currentPage: Math.max(page, 1),
     perPage,
     totalPages: Math.ceil(count / perPage),
-  };
+  } satisfies FindResultSet<typeof maskedData>;
 };

packages/lib/server-only/document/get-stats.ts

@@ -1,30 +1,88 @@
 import { prisma } from '@documenso/prisma';
-import { DocumentStatus } from '@documenso/prisma/client';
+import { SigningStatus, User } from '@documenso/prisma/client';
+import { isExtendedDocumentStatus } from '@documenso/prisma/guards/is-extended-document-status';
+import { ExtendedDocumentStatus } from '@documenso/prisma/types/extended-document-status';
 
 export type GetStatsInput = {
-  userId: number;
+  user: User;
 };
 
-export const getStats = async ({ userId }: GetStatsInput) => {
-  const result = await prisma.document.groupBy({
-    by: ['status'],
-    _count: {
-      _all: true,
-    },
-    where: {
-      userId,
-    },
-  });
+export const getStats = async ({ user }: GetStatsInput) => {
+  const [ownerCounts, notSignedCounts, hasSignedCounts] = await Promise.all([
+    prisma.document.groupBy({
+      by: ['status'],
+      _count: {
+        _all: true,
+      },
+      where: {
+        userId: user.id,
+      },
+    }),
+    prisma.document.groupBy({
+      by: ['status'],
+      _count: {
+        _all: true,
+      },
+      where: {
+        status: ExtendedDocumentStatus.PENDING,
+        Recipient: {
+          some: {
+            email: user.email,
+            signingStatus: SigningStatus.NOT_SIGNED,
+          },
+        },
+      },
+    }),
+    prisma.document.groupBy({
+      by: ['status'],
+      _count: {
+        _all: true,
+      },
+      where: {
+        status: {
+          not: ExtendedDocumentStatus.DRAFT,
+        },
+        Recipient: {
+          some: {
+            email: user.email,
+            signingStatus: SigningStatus.SIGNED,
+          },
+        },
+      },
+    }),
+  ]);
 
-  const stats: Record<DocumentStatus, number> = {
-    [DocumentStatus.DRAFT]: 0,
-    [DocumentStatus.PENDING]: 0,
-    [DocumentStatus.COMPLETED]: 0,
+  const stats: Record<ExtendedDocumentStatus, number> = {
+    [ExtendedDocumentStatus.DRAFT]: 0,
+    [ExtendedDocumentStatus.PENDING]: 0,
+    [ExtendedDocumentStatus.COMPLETED]: 0,
+    [ExtendedDocumentStatus.INBOX]: 0,
+    [ExtendedDocumentStatus.ALL]: 0,
   };
 
-  result.forEach((stat) => {
+  ownerCounts.forEach((stat) => {
     stats[stat.status] = stat._count._all;
   });
 
+  notSignedCounts.forEach((stat) => {
+    stats[ExtendedDocumentStatus.INBOX] += stat._count._all;
+  });
+
+  hasSignedCounts.forEach((stat) => {
+    if (stat.status === ExtendedDocumentStatus.COMPLETED) {
+      stats[ExtendedDocumentStatus.COMPLETED] += stat._count._all;
+    }
+
+    if (stat.status === ExtendedDocumentStatus.PENDING) {
+      stats[ExtendedDocumentStatus.PENDING] += stat._count._all;
+    }
+  });
+
+  Object.keys(stats).forEach((key) => {
+    if (key !== ExtendedDocumentStatus.ALL && isExtendedDocumentStatus(key)) {
+      stats[ExtendedDocumentStatus.ALL] += stats[key];
+    }
+  });
+
   return stats;
 };

packages/lib/server-only/field/set-fields-for-document.ts

@@ -84,6 +84,8 @@ export const setFieldsForDocument = async ({
           })
         : prisma.field.create({
             data: {
+              // TODO: Rewrite this entire transaction because this is a mess
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
               type: field.type!,
               page: field.pageNumber,
               positionX: field.pageX,

packages/lib/server-only/stripe/index.ts

@@ -1,7 +1,6 @@
 import Stripe from 'stripe';
 
-// eslint-disable-next-line turbo/no-undeclared-env-vars
-export const stripe = new Stripe(process.env.NEXT_PRIVATE_STRIPE_API_KEY!, {
+export const stripe = new Stripe(process.env.NEXT_PRIVATE_STRIPE_API_KEY ?? '', {
   apiVersion: '2022-11-15',
   typescript: true,
 });

packages/lib/server-only/subscription/get-subscription-by-user-id.ts

@@ -0,0 +1,15 @@
+'use server';
+
+import { prisma } from '@documenso/prisma';
+
+export type GetSubscriptionByUserIdOptions = {
+  userId: number;
+};
+
+export const getSubscriptionByUserId = ({ userId }: GetSubscriptionByUserIdOptions) => {
+  return prisma.subscription.findFirst({
+    where: {
+      userId,
+    },
+  });
+};

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

@@ -1,4 +1,4 @@
-import { hash } from 'bcrypt';
+import { compare, hash } from 'bcrypt';
 
 import { prisma } from '@documenso/prisma';
 
@@ -11,7 +11,7 @@ export type UpdatePasswordOptions = {
 
 export const updatePassword = async ({ userId, password }: UpdatePasswordOptions) => {
   // Existence check
-  await prisma.user.findFirstOrThrow({
+  const user = await prisma.user.findFirstOrThrow({
     where: {
       id: userId,
     },
@@ -19,6 +19,15 @@ export const updatePassword = async ({ userId, password }: UpdatePasswordOptions
 
   const hashedPassword = await hash(password, SALT_ROUNDS);
 
+  if (user.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.');
+    }
+  }
+
   const updatedUser = await prisma.user.update({
     where: {
       id: userId,

packages/lib/types/find-result-set.ts

@@ -1,5 +1,5 @@
 export type FindResultSet<T> = {
-  data: T[];
+  data: T extends Array<unknown> ? T : T[];
   count: number;
   currentPage: number;
   perPage: number;

packages/lib/types/is-document-status.ts

@@ -1,5 +1,6 @@
 import { DocumentStatus } from '@documenso/prisma/client';
 
 export const isDocumentStatus = (value: unknown): value is DocumentStatus => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return Object.values(DocumentStatus).includes(value as DocumentStatus);
 };