Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

3.7 KB
Raw Blame
import { createId } from "@/lib/api/create-id";
import { DubApiError } from "@/lib/api/errors";
import { parseRequestBody } from "@/lib/api/utils";
import { withWorkspace } from "@/lib/auth";
import { exceededLimitError } from "@/lib/exceeded-limit-error";
import { getFolders } from "@/lib/folder/get-folders";
import { getPlanCapabilities } from "@/lib/plan-capabilities";
import { prisma } from "@/lib/prisma";
import {
  createFolderSchema,
  FolderSchema,
  listFoldersQuerySchema,
} from "@/lib/zod/schemas/folders";
import { Prisma } from "@prisma/client";
import { NextResponse } from "next/server";

// GET /api/folders - get all folders for a workspace
export const GET = withWorkspace(
  async ({ workspace, headers, session, searchParams }) => {
    const { search, pageSize, page } =
      listFoldersQuerySchema.parse(searchParams);

    const folders = await getFolders({
      workspaceId: workspace.id,
      userId: session.user.id,
      search,
      pageSize,
      page,
    });

    return NextResponse.json(FolderSchema.array().parse(folders), {
      headers,
    });
  },
  {
    requiredPermissions: ["folders.read"],
  },
);

// POST /api/folders - create a folder for a workspace
export const POST = withWorkspace(
  async ({ req, workspace, headers, session }) => {
    const { name, description, accessLevel } = createFolderSchema.parse(
      await parseRequestBody(req),
    );

    const { canManageFolderPermissions } = getPlanCapabilities(workspace.plan);

    if (!canManageFolderPermissions && accessLevel !== "write") {
      throw new DubApiError({
        code: "forbidden",
        message:
          "You can only change the access level of a folder on Business and above plans.",
      });
    }

    try {
      const newFolder = await prisma.$transaction(
        async (tx) => {
          const result = await tx.$queryRaw<
            Array<{ foldersUsage: number; foldersLimit: number }>
          >`SELECT foldersUsage, foldersLimit FROM Project WHERE id = ${workspace.id} FOR UPDATE`;

          const { foldersUsage, foldersLimit } = result[0];

          if (foldersUsage >= foldersLimit) {
            throw new DubApiError({
              code: "exceeded_limit",
              message: exceededLimitError({
                plan: workspace.plan,
                planPeriod: workspace.planPeriod,
                limit: foldersLimit,
                type: "folders",
              }),
            });
          }

          const newFolder = await tx.folder.create({
            data: {
              id: createId({ prefix: "fold_" }),
              projectId: workspace.id,
              name,
              description,
              accessLevel,
              users: {
                create: {
                  userId: session.user.id,
                  role: "owner",
                },
              },
            },
          });

          await tx.project.update({
            where: {
              id: workspace.id,
            },
            data: {
              foldersUsage: {
                increment: 1,
              },
            },
          });

          return newFolder;
        },
        {
          isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead,
          maxWait: 5000,
          timeout: 5000,
        },
      );

      return NextResponse.json(FolderSchema.parse(newFolder), {
        headers,
        status: 201,
      });
    } catch (error) {
      if (error.code === "P2002") {
        throw new DubApiError({
          code: "conflict",
          message: `A folder with the name ${name} already exists.`,
        });
      }

      throw error;
    }
  },
  {
    requiredPermissions: ["folders.write"],
    requiredPlan: ["pro", "business", "advanced", "enterprise"],
  },
);