@mindbase/express-knowledge 1.0.1 → 1.0.8

package/service/KnowledgeService.ts

@@ -0,0 +1,515 @@
+import { knowledge } from "../orm/Knowledge.schema";
+import { eq, and, or, like, sql, desc, inArray } from "drizzle-orm";
+import { buildPath, getLevel, validatePath, isDescendant } from "../utils/path-builder";
+import type { Knowledge, KnowledgeSafe, InsertKnowledge } from "../types";
+
+let _db: any;
+
+/**
+ * 初始化 Service 的数据库实例
+ */
+export function initKnowledgeService(db: any) {
+  _db = db;
+}
+
+function getDB() {
+  if (!_db) throw new Error("KnowledgeService not initialized with DB");
+  return _db;
+}
+
+// ==================== CRUD 操作 ====================
+
+/**
+ * 创建知识库内容
+ */
+export async function createKnowledge(data: InsertKnowledge & { userId: number }) {
+  const db = getDB();
+  const now = new Date();
+
+  // 如果有父节点，获取父节点信息
+  let parentPath = "/";
+  let level = 0;
+
+  if (data.parentId) {
+    const [parent] = await db
+      .select()
+      .from(knowledge)
+      .where(and(eq(knowledge.id, data.parentId), eq(knowledge.isDelete, 0)))
+      .limit(1);
+
+    if (!parent) {
+      throw new Error("父节点不存在");
+    }
+
+    parentPath = parent.path;
+    level = parent.level + 1;
+  }
+
+  // 先插入基础数据（不含 path 和 level）
+  const result = await db
+    .insert(knowledge)
+    .values({
+      name: data.name,
+      type: data.type ?? 0,
+      safe: data.safe ?? 0,
+      userId: data.userId,
+      description: data.description,
+      content: data.content,
+      contentText: data.contentText,
+      viewType: data.viewType,
+      coverImage: data.coverImage,
+      author: data.author,
+      isbn: data.isbn,
+      created: now,
+      updated: now,
+      isDelete: 0,
+      isTop: 0,
+      path: "/", // 临时值
+      level: 0, // 临时值
+    })
+    .execute();
+
+  // 获取插入的 ID
+  const lastId = result.lastInsertRowid as number;
+
+  // 更新 path 和 level
+  const finalPath = buildPath(parentPath, lastId);
+  await db
+    .update(knowledge)
+    .set({ path: finalPath, level })
+    .where(eq(knowledge.id, lastId))
+    .execute();
+
+  return getKnowledgeById(lastId);
+}
+
+/**
+ * 批量创建知识库内容
+ */
+export async function createKnowledgeBatch(items: Array<{ name: string; type: number }>, userId: number, parentId?: number) {
+  const results = [];
+
+  for (const item of items) {
+    try {
+      const result = await createKnowledge({ ...item, userId, parentId });
+      results.push({ success: true, data: result });
+    } catch (error) {
+      results.push({ success: false, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 分页获取知识库列表
+ */
+export async function listKnowledge(options: {
+  pageIndex: number;
+  pageSize: number;
+  level?: number;
+  type?: number;
+  safe?: number[];
+  userId?: number;
+  isAdmin?: boolean;
+}) {
+  const db = getDB();
+  const { pageIndex, pageSize, level, type, safe = [0], userId, isAdmin } = options;
+
+  let conditions = [eq(knowledge.isDelete, 0)];
+
+  // 层级筛选
+  if (level !== undefined) {
+    conditions.push(eq(knowledge.level, level));
+  }
+
+  // 类型筛选
+  if (type !== undefined) {
+    conditions.push(eq(knowledge.type, type));
+  }
+
+  // 权限筛选
+  const safeConditions = [];
+  for (const s of safe) {
+    switch (s) {
+      case 0: // 公开
+        safeConditions.push(eq(knowledge.safe, s));
+        break;
+      case 1: // 登录共享
+        if (userId) {
+          safeConditions.push(eq(knowledge.safe, s));
+        }
+        break;
+      case 2: // 个人私密
+        if (userId) {
+          safeConditions.push(
+            and(eq(knowledge.safe, s), isAdmin ? sql`1=1` : eq(knowledge.userId, userId))
+          );
+        }
+        break;
+    }
+  }
+
+  if (safeConditions.length > 0) {
+    conditions.push(or(...safeConditions));
+  }
+
+  const offset = (pageIndex - 1) * pageSize;
+
+  const list = await db
+    .select()
+    .from(knowledge)
+    .where(and(...conditions))
+    .limit(pageSize)
+    .offset(offset)
+    .orderBy(desc(knowledge.isTop), desc(knowledge.created))
+    .execute();
+
+  const [totalResult] = await db
+    .select({ count: sql<number>`count(*)` })
+    .from(knowledge)
+    .where(and(...conditions))
+    .execute();
+
+  return {
+    list,
+    total: totalResult.count,
+    pageIndex,
+    pageSize,
+  };
+}
+
+/**
+ * 获取知识库详情
+ */
+export async function getKnowledgeById(id: number): Promise<Knowledge | null> {
+  const db = getDB();
+  const [item] = await db
+    .select()
+    .from(knowledge)
+    .where(and(eq(knowledge.id, id), eq(knowledge.isDelete, 0)))
+    .limit(1);
+
+  return item || null;
+}
+
+/**
+ * 批量获取知识库详情
+ */
+export async function getKnowledgeByIds(ids: number[]): Promise<Knowledge[]> {
+  const db = getDB();
+  if (ids.length === 0) return [];
+
+  return await db
+    .select()
+    .from(knowledge)
+    .where(and(inArray(knowledge.id, ids), eq(knowledge.isDelete, 0)))
+    .execute();
+}
+
+/**
+ * 获取知识库目录树
+ */
+export async function getKnowledgeTree(options: {
+  parentId?: number | null;
+  safe?: number[];
+  userId?: number;
+  isAdmin?: boolean;
+}) {
+  const db = getDB();
+  const { parentId = null, safe = [0], userId, isAdmin } = options;
+
+  let conditions = [eq(knowledge.isDelete, 0)];
+
+  // 权限筛选
+  const safeConditions = [];
+  for (const s of safe) {
+    switch (s) {
+      case 0: // 公开
+        safeConditions.push(eq(knowledge.safe, s));
+        break;
+      case 1: // 登录共享
+        if (userId) {
+          safeConditions.push(eq(knowledge.safe, s));
+        }
+        break;
+      case 2: // 个人私密
+        if (userId) {
+          safeConditions.push(
+            and(eq(knowledge.safe, s), isAdmin ? sql`1=1` : eq(knowledge.userId, userId))
+          );
+        }
+        break;
+    }
+  }
+
+  if (safeConditions.length > 0) {
+    conditions.push(or(...safeConditions));
+  }
+
+  // 如果指定了 parentId，只获取该节点下的子树
+  if (parentId !== null) {
+    const [parent] = await db
+      .select()
+      .from(knowledge)
+      .where(and(eq(knowledge.id, parentId), eq(knowledge.isDelete, 0)))
+      .limit(1);
+
+    if (!parent) return [];
+
+    conditions.push(like(knowledge.path, `${parent.path}%`));
+  }
+
+  const allNodes = await db
+    .select()
+    .from(knowledge)
+    .where(and(...conditions))
+    .orderBy(desc(knowledge.isTop), knowledge.name)
+    .execute();
+
+  // 使用 tree-builder 构建树形结构
+  const { buildTree } = await import("../utils/tree-builder");
+  return buildTree(allNodes, parentId);
+}
+
+/**
+ * 获取子节点列表
+ */
+export async function getChildren(parentId: number) {
+  const db = getDB();
+
+  const [parent] = await db
+    .select()
+    .from(knowledge)
+    .where(and(eq(knowledge.id, parentId), eq(knowledge.isDelete, 0)))
+    .limit(1);
+
+  if (!parent) {
+    throw new Error("父节点不存在");
+  }
+
+  return await db
+    .select()
+    .from(knowledge)
+    .where(
+      and(
+        eq(knowledge.isDelete, 0),
+        like(knowledge.path, `${parent.path}%`),
+        eq(knowledge.level, parent.level + 1)
+      )
+    )
+    .orderBy(desc(knowledge.isTop), knowledge.name)
+    .execute();
+}
+
+/**
+ * 更新知识库内容
+ */
+export async function updateKnowledge(id: number, data: Partial<InsertKnowledge>, userId: number) {
+  const db = getDB();
+  const now = new Date();
+
+  const result = await db
+    .update(knowledge)
+    .set({
+      ...(data.name !== undefined && { name: data.name }),
+      ...(data.description !== undefined && { description: data.description }),
+      ...(data.content !== undefined && { content: data.content }),
+      ...(data.contentText !== undefined && { contentText: data.contentText }),
+      ...(data.viewType !== undefined && { viewType: data.viewType }),
+      ...(data.coverImage !== undefined && { coverImage: data.coverImage }),
+      ...(data.author !== undefined && { author: data.author }),
+      ...(data.isbn !== undefined && { isbn: data.isbn }),
+      updated: now,
+    })
+    .where(and(eq(knowledge.id, id), eq(knowledge.userId, userId)))
+    .execute();
+
+  return result;
+}
+
+/**
+ * 移动节点（更新整个子树的 path 和 level）
+ */
+export async function moveKnowledge(nodeId: number, newParentId: number, userId: number) {
+  const db = getDB();
+
+  // 1. 获取节点和新父节点信息
+  const [node] = await db
+    .select()
+    .from(knowledge)
+    .where(and(eq(knowledge.id, nodeId), eq(knowledge.isDelete, 0)))
+    .limit(1);
+
+  const [newParent] = await db
+    .select()
+    .from(knowledge)
+    .where(and(eq(knowledge.id, newParentId), eq(knowledge.isDelete, 0)))
+    .limit(1);
+
+  if (!node || !newParent) {
+    throw new Error("节点不存在");
+  }
+
+  // 权限检查
+  if (node.userId !== userId) {
+    throw new Error("无权操作此节点");
+  }
+
+  // 2. 防止循环：不能移动到自己的后代节点
+  if (isDescendant(node.path, newParent.path)) {
+    throw new Error("不能移动到自己的后代节点");
+  }
+
+  const oldPath = node.path;
+  const newPath = buildPath(newParent.path, nodeId);
+  const levelDiff = newParent.level + 1 - node.level;
+
+  // 3. 批量更新整个子树
+  await db
+    .update(knowledge)
+    .set({
+      path: sql`REPLACE(${knowledge.path}, ${oldPath}, ${newPath})`,
+      level: sql`${knowledge.level} + ${levelDiff}`,
+    })
+    .where(or(like(knowledge.path, `${oldPath}%`), eq(knowledge.path, oldPath)))
+    .execute();
+
+  return getKnowledgeById(nodeId);
+}
+
+/**
+ * 更新置顶状态
+ */
+export async function updateIsTop(id: number, isTop: number, userId: number) {
+  const db = getDB();
+  const now = new Date();
+
+  await db
+    .update(knowledge)
+    .set({ isTop, updated: now })
+    .where(and(eq(knowledge.id, id), eq(knowledge.userId, userId)))
+    .execute();
+
+  return getKnowledgeById(id);
+}
+
+/**
+ * 更新安全等级
+ */
+export async function updateSafe(id: number, safe: KnowledgeSafe, userId: number) {
+  const db = getDB();
+  const now = new Date();
+
+  await db
+    .update(knowledge)
+    .set({ safe, updated: now })
+    .where(and(eq(knowledge.id, id), eq(knowledge.userId, userId)))
+    .execute();
+
+  return getKnowledgeById(id);
+}
+
+/**
+ * 逻辑删除
+ */
+export async function deleteKnowledge(id: number, userId: number) {
+  const db = getDB();
+  const now = new Date();
+
+  await db
+    .update(knowledge)
+    .set({ isDelete: 1, updated: now })
+    .where(and(eq(knowledge.id, id), eq(knowledge.userId, userId)))
+    .execute();
+
+  return { success: true };
+}
+
+/**
+ * 真实删除（管理员）
+ */
+export async function deleteKnowledgeReal(id: number) {
+  const db = getDB();
+
+  await db
+    .delete(knowledge)
+    .where(eq(knowledge.id, id))
+    .execute();
+
+  return { success: true };
+}
+
+/**
+ * 搜索知识库内容
+ */
+export async function searchKnowledge(options: {
+  keyword: string;
+  pageIndex?: number;
+  pageSize?: number;
+  safe?: number[];
+  userId?: number;
+  isAdmin?: boolean;
+}) {
+  const db = getDB();
+  const { keyword, pageIndex = 1, pageSize = 10, safe = [0], userId, isAdmin } = options;
+
+  let conditions = [
+    eq(knowledge.isDelete, 0),
+    or(
+      like(knowledge.name, `%${keyword}%`),
+      like(knowledge.description, `%${keyword}%`),
+      like(knowledge.contentText, `%${keyword}%`)
+    ),
+  ];
+
+  // 权限筛选
+  const safeConditions = [];
+  for (const s of safe) {
+    switch (s) {
+      case 0: // 公开
+        safeConditions.push(eq(knowledge.safe, s));
+        break;
+      case 1: // 登录共享
+        if (userId) {
+          safeConditions.push(eq(knowledge.safe, s));
+        }
+        break;
+      case 2: // 个人私密
+        if (userId) {
+          safeConditions.push(
+            and(eq(knowledge.safe, s), isAdmin ? sql`1=1` : eq(knowledge.userId, userId))
+          );
+        }
+        break;
+    }
+  }
+
+  if (safeConditions.length > 0) {
+    conditions.push(or(...safeConditions));
+  }
+
+  const offset = (pageIndex - 1) * pageSize;
+
+  const list = await db
+    .select()
+    .from(knowledge)
+    .where(and(...conditions))
+    .limit(pageSize)
+    .offset(offset)
+    .orderBy(desc(knowledge.created))
+    .execute();
+
+  const [totalResult] = await db
+    .select({ count: sql<number>`count(*)` })
+    .from(knowledge)
+    .where(and(...conditions))
+    .execute();
+
+  return {
+    list,
+    total: totalResult.count,
+    pageIndex,
+    pageSize,
+  };
+}