feat: add API support for folders (#1967)

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

@@ -1,7 +1,9 @@
 import { prisma } from '@documenso/prisma';
 
+import { AppError, AppErrorCode } from '../../errors/app-error';
 import type { TFolderType } from '../../types/folder-type';
 import { FolderType } from '../../types/folder-type';
+import { buildTeamWhereQuery } from '../../utils/teams';
 import { getTeamSettings } from '../team/get-team-settings';
 
 export interface CreateFolderOptions {
@@ -22,6 +24,27 @@ export const createFolder = async ({
   // This indirectly verifies whether the user has access to the team.
   const settings = await getTeamSettings({ userId, teamId });
 
+  if (parentId) {
+    const parentFolder = await prisma.folder.findFirst({
+      where: {
+        id: parentId,
+        team: buildTeamWhereQuery({ teamId, userId }),
+      },
+    });
+
+    if (!parentFolder) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Parent folder not found',
+      });
+    }
+
+    if (parentFolder.type !== type) {
+      throw new AppError(AppErrorCode.INVALID_BODY, {
+        message: 'Parent folder type does not match the folder type',
+      });
+    }
+  }
+
   return await prisma.folder.create({
     data: {
       name,

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

@@ -1,6 +1,7 @@
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { prisma } from '@documenso/prisma';
 
+import { TEAM_DOCUMENT_VISIBILITY_MAP } from '../../constants/teams';
 import { buildTeamWhereQuery, canAccessTeamDocument } from '../../utils/teams';
 import { getTeamById } from '../team/get-team';
 
@@ -20,6 +21,9 @@ export const deleteFolder = async ({ userId, teamId, folderId }: DeleteFolderOpt
         teamId,
         userId,
       }),
+      visibility: {
+        in: TEAM_DOCUMENT_VISIBILITY_MAP[team.currentTeamRole],
+      },
     },
   });
 
@@ -39,7 +43,7 @@ export const deleteFolder = async ({ userId, teamId, folderId }: DeleteFolderOpt
 
   return await prisma.folder.delete({
     where: {
-      id: folderId,
+      id: folder.id,
     },
   });
 };

packages/lib/server-only/folder/find-folders-internal.ts

@@ -0,0 +1,117 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { prisma } from '@documenso/prisma';
+
+import { TEAM_DOCUMENT_VISIBILITY_MAP } from '../../constants/teams';
+import type { TFolderType } from '../../types/folder-type';
+import { getTeamById } from '../team/get-team';
+
+export interface FindFoldersInternalOptions {
+  userId: number;
+  teamId: number;
+  parentId?: string | null;
+  type?: TFolderType;
+}
+
+export const findFoldersInternal = async ({
+  userId,
+  teamId,
+  parentId,
+  type,
+}: FindFoldersInternalOptions) => {
+  const team = await getTeamById({ userId, teamId });
+
+  const visibilityFilters = {
+    visibility: {
+      in: TEAM_DOCUMENT_VISIBILITY_MAP[team.currentTeamRole],
+    },
+  };
+
+  const whereClause = {
+    AND: [
+      { parentId },
+      {
+        OR: [
+          { teamId, ...visibilityFilters },
+          { userId, teamId },
+        ],
+      },
+    ],
+  };
+
+  try {
+    const folders = await prisma.folder.findMany({
+      where: {
+        ...whereClause,
+        ...(type ? { type } : {}),
+      },
+      orderBy: [{ pinned: 'desc' }, { createdAt: 'desc' }],
+    });
+
+    const foldersWithDetails = await Promise.all(
+      folders.map(async (folder) => {
+        try {
+          const [subfolders, documentCount, templateCount, subfolderCount] = await Promise.all([
+            prisma.folder.findMany({
+              where: {
+                parentId: folder.id,
+                teamId,
+                ...visibilityFilters,
+              },
+              orderBy: {
+                createdAt: 'desc',
+              },
+            }),
+            prisma.envelope.count({
+              where: {
+                type: EnvelopeType.DOCUMENT,
+                folderId: folder.id,
+              },
+            }),
+            prisma.envelope.count({
+              where: {
+                type: EnvelopeType.TEMPLATE,
+                folderId: folder.id,
+              },
+            }),
+            prisma.folder.count({
+              where: {
+                parentId: folder.id,
+                teamId,
+                ...visibilityFilters,
+              },
+            }),
+          ]);
+
+          const subfoldersWithEmptySubfolders = subfolders.map((subfolder) => ({
+            ...subfolder,
+            subfolders: [],
+            _count: {
+              documents: 0,
+              templates: 0,
+              subfolders: 0,
+            },
+          }));
+
+          return {
+            ...folder,
+            subfolders: subfoldersWithEmptySubfolders,
+            _count: {
+              documents: documentCount,
+              templates: templateCount,
+              subfolders: subfolderCount,
+            },
+          };
+        } catch (error) {
+          console.error('Error processing folder:', folder.id, error);
+          throw error;
+        }
+      }),
+    );
+
+    return foldersWithDetails;
+  } catch (error) {
+    console.error('Error in findFolders:', error);
+    throw error;
+  }
+};

packages/lib/server-only/folder/find-folders.ts

@@ -1,9 +1,11 @@
-import { EnvelopeType } from '@prisma/client';
+import type { Prisma } from '@prisma/client';
 
 import { prisma } from '@documenso/prisma';
 
 import { TEAM_DOCUMENT_VISIBILITY_MAP } from '../../constants/teams';
 import type { TFolderType } from '../../types/folder-type';
+import type { FindResultResponse } from '../../types/search-params';
+import { buildTeamWhereQuery } from '../../utils/teams';
 import { getTeamById } from '../team/get-team';
 
 export interface FindFoldersOptions {
@@ -11,102 +13,48 @@ export interface FindFoldersOptions {
   teamId: number;
   parentId?: string | null;
   type?: TFolderType;
+  page?: number;
+  perPage?: number;
 }
 
-export const findFolders = async ({ userId, teamId, parentId, type }: FindFoldersOptions) => {
+export const findFolders = async ({
+  userId,
+  teamId,
+  parentId,
+  type,
+  page = 1,
+  perPage = 10,
+}: FindFoldersOptions) => {
   const team = await getTeamById({ userId, teamId });
 
-  const visibilityFilters = {
+  const whereClause: Prisma.FolderWhereInput = {
+    parentId,
+    team: buildTeamWhereQuery({ teamId, userId }),
+    type,
     visibility: {
       in: TEAM_DOCUMENT_VISIBILITY_MAP[team.currentTeamRole],
     },
   };
 
-  const whereClause = {
-    AND: [
-      { parentId },
-      {
-        OR: [
-          { teamId, ...visibilityFilters },
-          { userId, teamId },
-        ],
+  const [data, count] = await Promise.all([
+    prisma.folder.findMany({
+      where: whereClause,
+      skip: Math.max(page - 1, 0) * perPage,
+      take: perPage,
+      orderBy: {
+        createdAt: 'desc',
       },
-    ],
-  };
+    }),
+    prisma.folder.count({
+      where: whereClause,
+    }),
+  ]);
 
-  try {
-    const folders = await prisma.folder.findMany({
-      where: {
-        ...whereClause,
-        ...(type ? { type } : {}),
-      },
-      orderBy: [{ pinned: 'desc' }, { createdAt: 'desc' }],
-    });
-
-    const foldersWithDetails = await Promise.all(
-      folders.map(async (folder) => {
-        try {
-          const [subfolders, documentCount, templateCount, subfolderCount] = await Promise.all([
-            prisma.folder.findMany({
-              where: {
-                parentId: folder.id,
-                teamId,
-                ...visibilityFilters,
-              },
-              orderBy: {
-                createdAt: 'desc',
-              },
-            }),
-            prisma.envelope.count({
-              where: {
-                type: EnvelopeType.DOCUMENT,
-                folderId: folder.id,
-              },
-            }),
-            prisma.envelope.count({
-              where: {
-                type: EnvelopeType.TEMPLATE,
-                folderId: folder.id,
-              },
-            }),
-            prisma.folder.count({
-              where: {
-                parentId: folder.id,
-                teamId,
-                ...visibilityFilters,
-              },
-            }),
-          ]);
-
-          const subfoldersWithEmptySubfolders = subfolders.map((subfolder) => ({
-            ...subfolder,
-            subfolders: [],
-            _count: {
-              documents: 0,
-              templates: 0,
-              subfolders: 0,
-            },
-          }));
-
-          return {
-            ...folder,
-            subfolders: subfoldersWithEmptySubfolders,
-            _count: {
-              documents: documentCount,
-              templates: templateCount,
-              subfolders: subfolderCount,
-            },
-          };
-        } catch (error) {
-          console.error('Error processing folder:', folder.id, error);
-          throw error;
-        }
-      }),
-    );
-
-    return foldersWithDetails;
-  } catch (error) {
-    console.error('Error in findFolders:', error);
-    throw error;
-  }
+  return {
+    data,
+    count,
+    currentPage: Math.max(page, 1),
+    perPage,
+    totalPages: Math.ceil(count / perPage),
+  } satisfies FindResultResponse<typeof data>;
 };

packages/lib/server-only/folder/get-folder-by-id.ts

@@ -1,51 +1,30 @@
-import { TeamMemberRole } from '@prisma/client';
-import { match } from 'ts-pattern';
-
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { prisma } from '@documenso/prisma';
 
-import { DocumentVisibility } from '../../types/document-visibility';
+import { TEAM_DOCUMENT_VISIBILITY_MAP } from '../../constants/teams';
 import type { TFolderType } from '../../types/folder-type';
+import { buildTeamWhereQuery } from '../../utils/teams';
 import { getTeamById } from '../team/get-team';
 
 export interface GetFolderByIdOptions {
   userId: number;
   teamId: number;
-  folderId?: string;
+  folderId: string;
   type?: TFolderType;
 }
 
 export const getFolderById = async ({ userId, teamId, folderId, type }: GetFolderByIdOptions) => {
   const team = await getTeamById({ userId, teamId });
 
-  const visibilityFilters = match(team.currentTeamRole)
-    .with(TeamMemberRole.ADMIN, () => ({
-      visibility: {
-        in: [
-          DocumentVisibility.EVERYONE,
-          DocumentVisibility.MANAGER_AND_ABOVE,
-          DocumentVisibility.ADMIN,
-        ],
-      },
-    }))
-    .with(TeamMemberRole.MANAGER, () => ({
-      visibility: {
-        in: [DocumentVisibility.EVERYONE, DocumentVisibility.MANAGER_AND_ABOVE],
-      },
-    }))
-    .otherwise(() => ({ visibility: DocumentVisibility.EVERYONE }));
-
-  const whereClause = {
-    id: folderId,
-    ...(type ? { type } : {}),
-    OR: [
-      { teamId, ...visibilityFilters },
-      { userId, teamId },
-    ],
-  };
-
   const folder = await prisma.folder.findFirst({
-    where: whereClause,
+    where: {
+      id: folderId,
+      team: buildTeamWhereQuery({ teamId, userId }),
+      type,
+      visibility: {
+        in: TEAM_DOCUMENT_VISIBILITY_MAP[team.currentTeamRole],
+      },
+    },
   });
 
   if (!folder) {

packages/lib/server-only/folder/move-folder.ts

@@ -1,89 +0,0 @@
-import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import type { ApiRequestMetadata } from '@documenso/lib/universal/extract-request-metadata';
-import { prisma } from '@documenso/prisma';
-
-import { buildTeamWhereQuery } from '../../utils/teams';
-
-export interface MoveFolderOptions {
-  userId: number;
-  teamId?: number;
-  folderId?: string;
-  parentId?: string | null;
-  requestMetadata?: ApiRequestMetadata;
-}
-
-export const moveFolder = async ({ userId, teamId, folderId, parentId }: MoveFolderOptions) => {
-  return await prisma.$transaction(async (tx) => {
-    const folder = await tx.folder.findFirst({
-      where: {
-        id: folderId,
-        team: buildTeamWhereQuery({
-          teamId,
-          userId,
-        }),
-      },
-    });
-
-    if (!folder) {
-      throw new AppError(AppErrorCode.NOT_FOUND, {
-        message: 'Folder not found',
-      });
-    }
-
-    if (parentId) {
-      const parentFolder = await tx.folder.findFirst({
-        where: {
-          id: parentId,
-          userId,
-          teamId,
-          type: folder.type,
-        },
-      });
-
-      if (!parentFolder) {
-        throw new AppError(AppErrorCode.NOT_FOUND, {
-          message: 'Parent folder not found',
-        });
-      }
-
-      if (parentId === folderId) {
-        throw new AppError(AppErrorCode.INVALID_REQUEST, {
-          message: 'Cannot move a folder into itself',
-        });
-      }
-
-      let currentParentId = parentFolder.parentId;
-      while (currentParentId) {
-        if (currentParentId === folderId) {
-          throw new AppError(AppErrorCode.INVALID_REQUEST, {
-            message: 'Cannot move a folder into its descendant',
-          });
-        }
-
-        const currentParent = await tx.folder.findUnique({
-          where: {
-            id: currentParentId,
-          },
-          select: {
-            parentId: true,
-          },
-        });
-
-        if (!currentParent) {
-          break;
-        }
-
-        currentParentId = currentParent.parentId;
-      }
-    }
-
-    return await tx.folder.update({
-      where: {
-        id: folderId,
-      },
-      data: {
-        parentId,
-      },
-    });
-  });
-};

packages/lib/server-only/folder/pin-folder.ts

@@ -1,40 +0,0 @@
-import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import { prisma } from '@documenso/prisma';
-
-import type { TFolderType } from '../../types/folder-type';
-import { buildTeamWhereQuery } from '../../utils/teams';
-
-export interface PinFolderOptions {
-  userId: number;
-  teamId?: number;
-  folderId: string;
-  type?: TFolderType;
-}
-
-export const pinFolder = async ({ userId, teamId, folderId, type }: PinFolderOptions) => {
-  const folder = await prisma.folder.findFirst({
-    where: {
-      id: folderId,
-      team: buildTeamWhereQuery({
-        teamId,
-        userId,
-      }),
-      type,
-    },
-  });
-
-  if (!folder) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Folder not found',
-    });
-  }
-
-  return await prisma.folder.update({
-    where: {
-      id: folderId,
-    },
-    data: {
-      pinned: true,
-    },
-  });
-};

packages/lib/server-only/folder/unpin-folder.ts

@@ -1,40 +0,0 @@
-import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import { prisma } from '@documenso/prisma';
-
-import type { TFolderType } from '../../types/folder-type';
-import { buildTeamWhereQuery } from '../../utils/teams';
-
-export interface UnpinFolderOptions {
-  userId: number;
-  teamId?: number;
-  folderId: string;
-  type?: TFolderType;
-}
-
-export const unpinFolder = async ({ userId, teamId, folderId, type }: UnpinFolderOptions) => {
-  const folder = await prisma.folder.findFirst({
-    where: {
-      id: folderId,
-      team: buildTeamWhereQuery({
-        teamId,
-        userId,
-      }),
-      type,
-    },
-  });
-
-  if (!folder) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Folder not found',
-    });
-  }
-
-  return await prisma.folder.update({
-    where: {
-      id: folderId,
-    },
-    data: {
-      pinned: false,
-    },
-  });
-};

packages/lib/server-only/folder/update-folder.ts

@@ -1,28 +1,28 @@
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { prisma } from '@documenso/prisma';
-import { DocumentVisibility } from '@documenso/prisma/generated/types';
+import type { DocumentVisibility } from '@documenso/prisma/generated/types';
 
-import type { TFolderType } from '../../types/folder-type';
-import { FolderType } from '../../types/folder-type';
+import { TEAM_DOCUMENT_VISIBILITY_MAP } from '../../constants/teams';
 import { buildTeamWhereQuery } from '../../utils/teams';
+import { getTeamById } from '../team/get-team';
 
 export interface UpdateFolderOptions {
   userId: number;
-  teamId?: number;
+  teamId: number;
   folderId: string;
-  name: string;
-  visibility: DocumentVisibility;
-  type?: TFolderType;
+  data: {
+    parentId?: string | null;
+    name?: string;
+    visibility?: DocumentVisibility;
+    pinned?: boolean;
+  };
 }
 
-export const updateFolder = async ({
-  userId,
-  teamId,
-  folderId,
-  name,
-  visibility,
-  type,
-}: UpdateFolderOptions) => {
+export const updateFolder = async ({ userId, teamId, folderId, data }: UpdateFolderOptions) => {
+  const { parentId, name, visibility, pinned } = data;
+
+  const team = await getTeamById({ userId, teamId });
+
   const folder = await prisma.folder.findFirst({
     where: {
       id: folderId,
@@ -30,7 +30,9 @@ export const updateFolder = async ({
         teamId,
         userId,
       }),
-      type,
+      visibility: {
+        in: TEAM_DOCUMENT_VISIBILITY_MAP[team.currentTeamRole],
+      },
     },
   });
 
@@ -40,17 +42,66 @@ export const updateFolder = async ({
     });
   }
 
-  const isTemplateFolder = folder.type === FolderType.TEMPLATE;
-  const effectiveVisibility =
-    isTemplateFolder && teamId !== null ? DocumentVisibility.EVERYONE : visibility;
+  if (parentId) {
+    const parentFolder = await prisma.folder.findFirst({
+      where: {
+        id: parentId,
+        team: buildTeamWhereQuery({ teamId, userId }),
+        type: folder.type,
+      },
+    });
+
+    if (!parentFolder) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Parent folder not found',
+      });
+    }
+
+    if (parentId === folderId) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Cannot move a folder into itself',
+      });
+    }
+
+    let currentParentId = parentFolder.parentId;
+
+    while (currentParentId) {
+      if (currentParentId === folderId) {
+        throw new AppError(AppErrorCode.INVALID_REQUEST, {
+          message: 'Cannot move a folder into its descendant',
+        });
+      }
+
+      const currentParent = await prisma.folder.findUnique({
+        where: {
+          id: currentParentId,
+        },
+        select: {
+          parentId: true,
+        },
+      });
+
+      if (!currentParent) {
+        break;
+      }
+
+      currentParentId = currentParent.parentId;
+    }
+  }
 
   return await prisma.folder.update({
     where: {
       id: folderId,
+      team: buildTeamWhereQuery({
+        teamId,
+        userId,
+      }),
     },
     data: {
       name,
-      visibility: effectiveVisibility,
+      visibility,
+      parentId,
+      pinned,
     },
   });
 };