fix: update board slug availability check to be unique to workspace

* feat: add patterned background to boards

* feat: setup dashboard 2.0

* fix: prevent patterned background from overlaying buttons

* feat: set max width for main card view

* feat: adjust colour scheme for card view

* feat: adjust dashboard border colour scheme and radius

* fix: use correct colour for description placeholder

* fix: use getLayout to persist layout state across pages

* feat: reduce max width for settings and members pages

* feat: add feedback button and modal

* feat: adjust page max width

* feat: extend mobile layout support

* fix: hide pro badge when collapsed

* feat: tweak nav styling for light mode

* feat: tweak skeleton loaders for board list

* feat: extend list max height

* fix: hide side nav right border on desktop

* chore: update hero images

* chore: update hero images for docs

* chore: update translations

apps/web/src/views/board/components/UpdateBoardSlugForm.tsx

@@ -167,7 +167,8 @@ export function UpdateBoardSlugForm({
               !isDirty ||
               updateBoardSlug.isPending ||
               errors.slug?.message !== undefined ||
-              isBoardSlugAvailable?.isReserved
+              isBoardSlugAvailable?.isReserved ||
+              checkBoardSlugAvailability.isLoading
             }
           >
             {t`Update`}

packages/api/src/routers/board.ts

@@ -276,6 +276,21 @@ export const boardRouter = createTRPCRouter({
 
       await assertUserInWorkspace(ctx.db, userId, board.workspaceId);
 
+      if (input.slug) {
+        const isBoardSlugAvailable = await boardRepo.isBoardSlugAvailable(
+          ctx.db,
+          input.slug,
+          board.workspaceId,
+        );
+
+        if (!isBoardSlugAvailable) {
+          throw new TRPCError({
+            message: `Board slug ${input.slug} is not available`,
+            code: "BAD_REQUEST",
+          });
+        }
+      }
+
       const result = await boardRepo.update(ctx.db, {
         name: input.name,
         slug: input.slug,
@@ -407,11 +422,23 @@ export const boardRouter = createTRPCRouter({
       }),
     )
     .query(async ({ ctx, input }) => {
+      const board = await boardRepo.getWorkspaceAndBoardIdByBoardPublicId(
+        ctx.db,
+        input.boardPublicId,
+      );
+
+      if (!board)
+        throw new TRPCError({
+          message: `Board with public ID ${input.boardPublicId} not found`,
+          code: "NOT_FOUND",
+        });
+
       const isBoardSlugAvailable = await boardRepo.isBoardSlugAvailable(
         ctx.db,
         input.boardSlug,
-        input.boardPublicId,
+        board.workspaceId,
       );
+
       return {
         isReserved: !isBoardSlugAvailable,
       };

packages/auth/src/auth.ts

@@ -166,9 +166,19 @@ export const initAuth = (db: dbClient) => {
     databaseHooks: {
       user: {
         create: {
-          before() {
+          async before(user) {
             if (env("NEXT_PUBLIC_DISABLE_SIGN_UP")?.toLowerCase() === "true") {
-              return Promise.resolve(false);
+              const pendingInvitation = await memberRepo.getByEmailAndStatus(
+                db,
+                user.email,
+                "invited",
+              );
+
+              if (!pendingInvitation) {
+                return Promise.resolve(false);
+              }
+
+              return Promise.resolve(true);
             }
             return Promise.resolve(true);
           },

packages/db/src/repository/board.repo.ts

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, exists, inArray, isNull, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, isNull, or } from "drizzle-orm";
 
 import type { dbClient } from "@kan/db/client";
 import type { BoardVisibilityStatus } from "@kan/db/schema";
@@ -481,30 +481,18 @@ export const getWorkspaceAndBoardIdByBoardPublicId = async (
 export const isBoardSlugAvailable = async (
   db: dbClient,
   boardSlug: string,
-  boardPublicId: string,
+  workspaceId: number,
 ) => {
-  const result = await db
-    .select({ id: boards.id })
-    .from(boards)
-    .where(
-      and(
-        eq(boards.publicId, boardPublicId),
-        exists(
-          db
-            .select({ id: boards.id })
-            .from(boards)
-            .where(
-              and(
-                eq(boards.slug, boardSlug),
-                eq(boards.workspaceId, sql`${boards.workspaceId}`), // Reference outer query's workspaceId
-                isNull(boards.deletedAt),
-              ),
-            )
-            .limit(1),
-        ),
-      ),
-    )
-    .limit(1);
+  const result = await db.query.boards.findFirst({
+    columns: {
+      id: true,
+    },
+    where: and(
+      eq(boards.slug, boardSlug),
+      eq(boards.workspaceId, workspaceId),
+      isNull(boards.deletedAt),
+    ),
+  });
 
-  return result.length === 0;
+  return result === undefined;
 };

packages/db/src/repository/member.repo.ts

@@ -41,6 +41,20 @@ export const getByPublicId = async (db: dbClient, publicId: string) => {
   });
 };
 
+export const getByEmailAndStatus = async (
+  db: dbClient,
+  email: string,
+  status: MemberStatus,
+) => {
+  return db.query.workspaceMembers.findFirst({
+    where: and(
+      eq(workspaceMembers.email, email),
+      eq(workspaceMembers.status, status),
+      isNull(workspaceMembers.deletedAt),
+    ),
+  });
+};
+
 export const acceptInvite = async (
   db: dbClient,
   args: { memberId: number; userId: string },