Improve POST /links endpoint performance

apps/web/app/api/links/[linkId]/route.ts

@@ -166,33 +166,26 @@ export const PATCH = withWorkspace(
       });
     }
 
-    try {
-      const response = await updateLink({
-        oldLink: {
-          domain: link.domain,
-          key: link.key,
-          image: link.image,
-        },
-        updatedLink: processedLink,
-      });
+    const response = await updateLink({
+      oldLink: {
+        domain: link.domain,
+        key: link.key,
+        image: link.image,
+      },
+      updatedLink: processedLink,
+    });
 
-      waitUntil(
-        sendWorkspaceWebhook({
-          trigger: "link.updated",
-          workspace,
-          data: linkEventSchema.parse(response),
-        }),
-      );
+    waitUntil(
+      sendWorkspaceWebhook({
+        trigger: "link.updated",
+        workspace,
+        data: linkEventSchema.parse(response),
+      }),
+    );
 
-      return NextResponse.json(response, {
-        headers,
-      });
-    } catch (error) {
-      throw new DubApiError({
-        code: "unprocessable_entity",
-        message: error.message,
-      });
-    }
+    return NextResponse.json(response, {
+      headers,
+    });
   },
   {
     requiredPermissions: ["links.write"],

apps/web/app/api/links/bulk/route.ts

@@ -245,8 +245,16 @@ export const POST = withWorkspace(
       });
     }
 
-    const validLinksResponse =
-      validLinks.length > 0 ? await bulkCreateLinks({ links: validLinks }) : [];
+    let validLinksResponse: ProcessedLinkProps[] = [];
+
+    if (validLinks.length > 0) {
+      const response = await bulkCreateLinks({
+        links: validLinks,
+      });
+
+      validLinksResponse.push(...response.validLinks);
+      errorLinks.push(...response.invalidLinks);
+    }
 
     return NextResponse.json([...validLinksResponse, ...errorLinks], {
       headers,

apps/web/app/api/links/random/route.ts

@@ -18,7 +18,6 @@ export const GET = async (req: NextRequest) => {
     await ratelimitOrThrow(req, "links-random");
 
     const response = await getRandomKey({
-      domain,
       long: domain === "loooooooo.ng",
     });
     return NextResponse.json(response);

apps/web/app/api/links/route.ts

@@ -1,7 +1,8 @@
 import { getFolderIdsToFilter } from "@/lib/analytics/get-folder-ids-to-filter";
 import { getDomainOrThrow } from "@/lib/api/domains/get-domain-or-throw";
 import { DubApiError, ErrorCodes } from "@/lib/api/errors";
-import { createLink, getLinksForWorkspace, processLink } from "@/lib/api/links";
+import { getLinksForWorkspace, processLink } from "@/lib/api/links";
+import { createLinkWithKeyRetry } from "@/lib/api/links/create-link-with-key-retry";
 import { throwIfLinksUsageExceeded } from "@/lib/api/links/usage-checks";
 import { parseRequestBody } from "@/lib/api/utils";
 import { withWorkspace } from "@/lib/auth";
@@ -96,6 +97,8 @@ export const POST = withWorkspace(
       }
     }
 
+    const { key } = body;
+
     const { link, error, code } = await processLink({
       payload: body,
       workspace,
@@ -109,28 +112,24 @@ export const POST = withWorkspace(
       });
     }
 
-    try {
-      const response = await createLink(link);
-
-      if (response.projectId && response.userId) {
-        waitUntil(
-          sendWorkspaceWebhook({
-            trigger: "link.created",
-            workspace,
-            data: linkEventSchema.parse(response),
-          }),
-        );
-      }
+    const response = await createLinkWithKeyRetry({
+      link,
+      isRandomKey: !key,
+    });
 
-      return NextResponse.json(response, {
-        headers,
-      });
-    } catch (error) {
-      throw new DubApiError({
-        code: "unprocessable_entity",
-        message: error.message,
-      });
+    if (response.projectId && response.userId) {
+      waitUntil(
+        sendWorkspaceWebhook({
+          trigger: "link.created",
+          workspace,
+          data: linkEventSchema.parse(response),
+        }),
+      );
     }
+
+    return NextResponse.json(response, {
+      headers,
+    });
   },
   {
     requiredPermissions: ["links.write"],

apps/web/app/api/links/upsert/route.ts

@@ -131,58 +131,47 @@ export const PUT = withWorkspace(
         });
       }
 
-      try {
-        const response = await updateLink({
-          oldLink: {
-            domain: link.domain,
-            key: link.key,
-            image: link.image,
-          },
-          updatedLink: processedLink,
-        });
+      const response = await updateLink({
+        oldLink: {
+          domain: link.domain,
+          key: link.key,
+          image: link.image,
+        },
+        updatedLink: processedLink,
+      });
 
-        waitUntil(
-          sendWorkspaceWebhook({
-            trigger: "link.updated",
-            workspace,
-            data: linkEventSchema.parse(response),
-          }),
-        );
+      waitUntil(
+        sendWorkspaceWebhook({
+          trigger: "link.updated",
+          workspace,
+          data: linkEventSchema.parse(response),
+        }),
+      );
 
-        return NextResponse.json(response, {
-          headers,
-        });
-      } catch (error) {
-        throw new DubApiError({
-          code: "unprocessable_entity",
-          message: error.message,
-        });
-      }
-    } else {
-      // proceed with /api/links POST logic
-      const { link, error, code } = await processLink({
-        payload: body,
-        workspace,
-        userId: session.user.id,
-      });
+      return NextResponse.json(response, { headers });
+    }
 
-      if (error != null) {
-        throw new DubApiError({
-          code: code as ErrorCodes,
-          message: error,
-        });
-      }
+    // Otherwise, proceed with /api/links POST logic
+    const {
+      link: processedLink,
+      error,
+      code,
+    } = await processLink({
+      payload: body,
+      workspace,
+      userId: session.user.id,
+    });
 
-      try {
-        const response = await createLink(link);
-        return NextResponse.json(response, { headers });
-      } catch (error) {
-        throw new DubApiError({
-          code: "unprocessable_entity",
-          message: error.message,
-        });
-      }
+    if (error != null) {
+      throw new DubApiError({
+        code: code as ErrorCodes,
+        message: error,
+      });
     }
+
+    const response = await createLink(processedLink);
+
+    return NextResponse.json(response, { headers });
   },
   {
     requiredPermissions: ["links.write"],

apps/web/lib/api/errors.ts

@@ -122,7 +122,7 @@ export function fromZodError(error: ZodError): ErrorResponse {
 }
 
 export function handleApiError(error: any): ErrorResponse & { status: number } {
-  console.error("API error occurred", error.message);
+  console.error(error.message);
 
   // Zod errors
   if (error instanceof ZodError) {

apps/web/lib/api/links/bulk-create-links.ts

@@ -21,13 +21,18 @@ export async function bulkCreateLinks({
   links: ProcessedLinkProps[];
   skipRedisCache?: boolean;
 }) {
-  if (links.length === 0) return [];
+  if (links.length === 0) {
+    return {
+      validLinks: [],
+      invalidLinks: [],
+    };
+  }
 
   const hasTags = checkIfLinksHaveTags(links);
   const hasWebhooks = checkIfLinksHaveWebhooks(links);
 
   // Create a map of shortLinks to their original indices at the start
-  const shortLinkToIndexMap = new Map(
+  let shortLinkToIndexMap = new Map(
     links.map((link, index) => {
       const key = encodeKeyIfCaseSensitive({
         domain: link.domain,
@@ -44,6 +49,60 @@ export async function bulkCreateLinks({
     }),
   );
 
+  // Check if any links already exist
+  const existingLinks = await prisma.link.findMany({
+    where: {
+      shortLink: {
+        in: Array.from(shortLinkToIndexMap.keys()),
+      },
+    },
+    select: {
+      shortLink: true,
+    },
+    take: shortLinkToIndexMap.size,
+  });
+
+  const invalidLinks: {
+    error: string;
+    code: string;
+    link: ProcessedLinkProps;
+  }[] = [];
+
+  if (existingLinks.length > 0) {
+    existingLinks.forEach((existingLink) => {
+      invalidLinks.push({
+        code: "conflict",
+        error: "Duplicate key: This short link already exists.",
+        link: links.find(
+          (l) =>
+            existingLink.shortLink ===
+            linkConstructorSimple({ domain: l.domain, key: l.key }),
+        ) as ProcessedLinkProps,
+      });
+    });
+  }
+
+  // Remove existing links from the links array
+  links = links.filter(
+    (link) =>
+      !existingLinks.some(
+        (l) =>
+          linkConstructorSimple({ domain: link.domain, key: link.key }) ===
+          l.shortLink,
+      ),
+  );
+
+  existingLinks.forEach((link) => {
+    shortLinkToIndexMap.delete(link.shortLink);
+  });
+
+  if (links.length === 0) {
+    return {
+      validLinks: [],
+      invalidLinks,
+    };
+  }
+
   // Create all links first using createMany
   await prisma.link.createMany({
     data: links.map(({ tagId, tagIds, tagNames, webhookIds, ...link }) => {
@@ -230,5 +289,10 @@ export async function bulkCreateLinks({
     return aIndex - bIndex;
   });
 
-  return createdLinksData.map((link) => transformLink(link));
+  return {
+    validLinks: createdLinksData.map(
+      (link) => transformLink(link) as ProcessedLinkProps,
+    ),
+    invalidLinks,
+  };
 }