GC-69 Delete, edit, and copy link of KB item/folder

server/src/data/db/schema.ts

@@ -721,6 +721,7 @@ export const knowledgeFolders = pgTable(
     updatedAt: timestamp("updated_at", { withTimezone: true })
       .defaultNow()
       .notNull(),
+    deletedAt: timestamp("deleted_at", { withTimezone: true }),
   },
   (table) => [
     index("ix_knowledge_folders_parent_folder_id").on(table.parentFolderId),
@@ -748,6 +749,7 @@ export const knowledgeItems = pgTable(
     updatedAt: timestamp("updated_at", { withTimezone: true })
       .defaultNow()
       .notNull(),
+    deletedAt: timestamp("deleted_at", { withTimezone: true }),
   },
   (table) => [
     index("ix_knowledge_items_folder_id").on(table.folderId),

server/src/data/repository/knowledge-repo.ts

@@ -1,4 +1,4 @@
-import { asc, eq, isNull } from "drizzle-orm";
+import { and, asc, eq, inArray, isNull } from "drizzle-orm";
 import {
   files,
   knowledgeAttachments,
@@ -41,7 +41,12 @@ export class KnowledgeRepository {
     return await db
       .select()
       .from(knowledgeFolders)
-      .where(isNull(knowledgeFolders.parentFolderId))
+      .where(
+        and(
+          isNull(knowledgeFolders.parentFolderId),
+          isNull(knowledgeFolders.deletedAt),
+        ),
+      )
       .orderBy(asc(knowledgeFolders.title));
   }
 
@@ -59,7 +64,12 @@ export class KnowledgeRepository {
       const [folder] = await db
         .select()
         .from(knowledgeFolders)
-        .where(eq(knowledgeFolders.folderId, cursor))
+        .where(
+          and(
+            eq(knowledgeFolders.folderId, cursor),
+            isNull(knowledgeFolders.deletedAt),
+          ),
+        )
         .limit(1);
       if (!folder) break;
       chain.push(folder);
@@ -76,7 +86,12 @@ export class KnowledgeRepository {
     return await db
       .select()
       .from(knowledgeFolders)
-      .where(eq(knowledgeFolders.parentFolderId, parentFolderId))
+      .where(
+        and(
+          eq(knowledgeFolders.parentFolderId, parentFolderId),
+          isNull(knowledgeFolders.deletedAt),
+        ),
+      )
       .orderBy(asc(knowledgeFolders.title));
   }
 
@@ -87,7 +102,12 @@ export class KnowledgeRepository {
     return await db
       .select()
       .from(knowledgeItems)
-      .where(eq(knowledgeItems.folderId, folderId))
+      .where(
+        and(
+          eq(knowledgeItems.folderId, folderId),
+          isNull(knowledgeItems.deletedAt),
+        ),
+      )
       .orderBy(asc(knowledgeItems.name));
   }
 
@@ -99,7 +119,12 @@ export class KnowledgeRepository {
     const [item] = await db
       .select()
       .from(knowledgeItems)
-      .where(eq(knowledgeItems.itemId, itemId))
+      .where(
+        and(
+          eq(knowledgeItems.itemId, itemId),
+          isNull(knowledgeItems.deletedAt),
+        ),
+      )
       .limit(1);
 
     if (!item) {
@@ -342,11 +367,66 @@ export class KnowledgeRepository {
     return deleted?.fileId ?? null;
   }
 
+  async deleteFolder(folderId: string) {
+    await this.ensureFolderExists(folderId);
+
+    const allFolderIds: string[] = [folderId];
+    const queue: string[] = [folderId];
+
+    while (queue.length > 0) {
+      const parentId = queue.shift()!;
+      const children = await db
+        .select({ folderId: knowledgeFolders.folderId })
+        .from(knowledgeFolders)
+        .where(
+          and(
+            eq(knowledgeFolders.parentFolderId, parentId),
+            isNull(knowledgeFolders.deletedAt),
+          ),
+        );
+      for (const child of children) {
+        allFolderIds.push(child.folderId);
+        queue.push(child.folderId);
+      }
+    }
+
+    const now = new Date();
+    await db.transaction(async (tx) => {
+      await tx
+        .update(knowledgeItems)
+        .set({ deletedAt: now })
+        .where(
+          and(
+            inArray(knowledgeItems.folderId, allFolderIds),
+            isNull(knowledgeItems.deletedAt),
+          ),
+        );
+      await tx
+        .update(knowledgeFolders)
+        .set({ deletedAt: now })
+        .where(inArray(knowledgeFolders.folderId, allFolderIds));
+    });
+  }
+
+  async deleteItem(itemId: string) {
+    await this.ensureItemExists(itemId);
+
+    await db
+      .update(knowledgeItems)
+      .set({ deletedAt: new Date() })
+      .where(eq(knowledgeItems.itemId, itemId));
+  }
+
   private async ensureFolderExists(folderId: string): Promise<void> {
     const [folder] = await db
       .select({ folderId: knowledgeFolders.folderId })
       .from(knowledgeFolders)
-      .where(eq(knowledgeFolders.folderId, folderId))
+      .where(
+        and(
+          eq(knowledgeFolders.folderId, folderId),
+          isNull(knowledgeFolders.deletedAt),
+        ),
+      )
       .limit(1);
 
     if (!folder) {
@@ -358,7 +438,12 @@ export class KnowledgeRepository {
     const [item] = await db
       .select({ itemId: knowledgeItems.itemId })
       .from(knowledgeItems)
-      .where(eq(knowledgeItems.itemId, itemId))
+      .where(
+        and(
+          eq(knowledgeItems.itemId, itemId),
+          isNull(knowledgeItems.deletedAt),
+        ),
+      )
       .limit(1);
 
     if (!item) {

server/src/routers/knowledge.ts

@@ -9,7 +9,9 @@ import {
   createFolderInputSchema,
   createItemAttachmentInputSchema,
   createItemInputSchema,
+  deleteFolderInputSchema,
   deleteItemAttachmentInputSchema,
+  deleteItemInputSchema,
   getFolderAncestorsInputSchema,
   getFoldersInFolderInputSchema,
   getItemAttachmentInputSchema,
@@ -261,6 +263,40 @@ const replaceItemAttachment = protectedProcedure
     }),
   );
 
+const deleteFolder = protectedProcedure
+  .input(deleteFolderInputSchema)
+  .output(simpleOkSchema)
+  .meta({
+    openapi: {
+      method: "POST",
+      path: "/knowledge.deleteFolder",
+      summary: "Soft-delete a folder and all its contents",
+      tags: ["Knowledge"],
+    },
+  })
+  .mutation(({ input }) =>
+    withErrorHandling("deleteFolder", async () => {
+      return await knowledgeService.deleteFolder(input.folderId);
+    }),
+  );
+
+const deleteItem = protectedProcedure
+  .input(deleteItemInputSchema)
+  .output(simpleOkSchema)
+  .meta({
+    openapi: {
+      method: "POST",
+      path: "/knowledge.deleteItem",
+      summary: "Soft-delete a knowledge item",
+      tags: ["Knowledge"],
+    },
+  })
+  .mutation(({ input }) =>
+    withErrorHandling("deleteItem", async () => {
+      return await knowledgeService.deleteItem(input.itemId);
+    }),
+  );
+
 const deleteItemAttachment = protectedProcedure
   .input(deleteItemAttachmentInputSchema)
   .output(simpleOkSchema)
@@ -292,5 +328,7 @@ export const knowledgeRouter = router({
   updateItem,
   createItemAttachment,
   replaceItemAttachment,
+  deleteFolder,
+  deleteItem,
   deleteItemAttachment,
 });

server/src/service/knowledge-service.ts

@@ -103,6 +103,16 @@ export class KnowledgeService {
     return attachment;
   }
 
+  async deleteFolder(folderId: string) {
+    await this.knowledgeRepo.deleteFolder(folderId);
+    return { ok: true };
+  }
+
+  async deleteItem(itemId: string) {
+    await this.knowledgeRepo.deleteItem(itemId);
+    return { ok: true };
+  }
+
   async deleteItemAttachment(itemId: string) {
     const oldFileId = await this.knowledgeRepo.deleteItemAttachment(itemId);
 

server/src/types/knowledge-types.ts

@@ -99,4 +99,12 @@ export const deleteItemAttachmentInputSchema = z.object({
   itemId: uuidSchema,
 });
 
+export const deleteFolderInputSchema = z.object({
+  folderId: uuidSchema,
+});
+
+export const deleteItemInputSchema = z.object({
+  itemId: uuidSchema,
+});
+
 export const simpleOkSchema = z.object({ ok: z.boolean() });

web/src/app/admin/page.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { RoleKey } from "@server/data/roles";
-import { BarChart2, ShieldCheck, UserPlus, Users } from "lucide-react";
+import { BarChart2, ShieldCheck, UserPlus } from "lucide-react";
 import type { Route } from "next";
 import Link from "next/link";
 import { AuthGuard } from "@/components/auth/auth-guard";