@mindbase/express-knowledge 1.0.4 → 1.0.8

package/service/TagService.ts

@@ -0,0 +1,271 @@
+import { knowledgeTag, knowledgeTagRelation } from "../orm/Tag.schema";
+import { knowledge } from "../orm/Knowledge.schema";
+import { eq, and, sql, desc, or, inArray } from "drizzle-orm";
+import type { InsertTag } from "../types";
+
+let _db: any;
+
+/**
+ * 初始化 Service 的数据库实例
+ */
+export function initTagService(db: any) {
+  _db = db;
+}
+
+function getDB() {
+  if (!_db) throw new Error("TagService not initialized with DB");
+  return _db;
+}
+
+// ==================== 标签管理 ====================
+
+/**
+ * 创建标签
+ */
+export async function createTag(data: InsertTag & { userId?: number }) {
+  const db = getDB();
+  const now = new Date();
+
+  const result = await db
+    .insert(knowledgeTag)
+    .values({
+      name: data.name,
+      color: data.color,
+      userId: data.userId,
+      created: now,
+    })
+    .execute();
+
+  const lastId = result.lastInsertRowid as number;
+  return getTagById(lastId);
+}
+
+/**
+ * 获取标签详情
+ */
+export async function getTagById(id: number) {
+  const db = getDB();
+  const [tag] = await db.select().from(knowledgeTag).where(eq(knowledgeTag.id, id)).limit(1);
+
+  return tag || null;
+}
+
+/**
+ * 获取标签列表
+ */
+export async function listTags(userId?: number) {
+  const db = getDB();
+
+  let conditions = [];
+  if (userId !== undefined) {
+    conditions.push(eq(knowledgeTag.userId, userId));
+  }
+
+  return await db
+    .select()
+    .from(knowledgeTag)
+    .where(conditions.length > 0 ? and(...conditions) : undefined)
+    .orderBy(knowledgeTag.name)
+    .execute();
+}
+
+/**
+ * 更新标签
+ */
+export async function updateTag(id: number, data: Partial<InsertTag>, userId: number) {
+  const db = getDB();
+
+  // 检查权限
+  const [tag] = await db
+    .select()
+    .from(knowledgeTag)
+    .where(and(eq(knowledgeTag.id, id), eq(knowledgeTag.userId, userId)))
+    .limit(1);
+
+  if (!tag) {
+    throw new Error("标签不存在或无权操作");
+  }
+
+  await db
+    .update(knowledgeTag)
+    .set({
+      ...(data.name !== undefined && { name: data.name }),
+      ...(data.color !== undefined && { color: data.color }),
+    })
+    .where(eq(knowledgeTag.id, id))
+    .execute();
+
+  return getTagById(id);
+}
+
+/**
+ * 删除标签
+ */
+export async function deleteTag(id: number, userId: number) {
+  const db = getDB();
+
+  // 检查权限
+  const [tag] = await db
+    .select()
+    .from(knowledgeTag)
+    .where(and(eq(knowledgeTag.id, id), eq(knowledgeTag.userId, userId)))
+    .limit(1);
+
+  if (!tag) {
+    throw new Error("标签不存在或无权操作");
+  }
+
+  // 删除标签关联
+  await db.delete(knowledgeTagRelation).where(eq(knowledgeTagRelation.tagId, id)).execute();
+
+  // 删除标签
+  await db.delete(knowledgeTag).where(eq(knowledgeTag.id, id)).execute();
+
+  return { success: true };
+}
+
+// ==================== 标签关联 ====================
+
+/**
+ * 为知识库内容添加标签
+ */
+export async function addTagToKnowledge(knowledgeId: number, tagId: number, userId: number) {
+  const db = getDB();
+
+  // 检查标签是否存在
+  const [tag] = await db.select().from(knowledgeTag).where(eq(knowledgeTag.id, tagId)).limit(1);
+
+  if (!tag) {
+    throw new Error("标签不存在");
+  }
+
+  // 检查是否已存在关联
+  const [existing] = await db
+    .select()
+    .from(knowledgeTagRelation)
+    .where(and(eq(knowledgeTagRelation.knowledgeId, knowledgeId), eq(knowledgeTagRelation.tagId, tagId)))
+    .limit(1);
+
+  if (existing) {
+    return { success: true, message: "标签已存在" };
+  }
+
+  // 创建关联
+  await db
+    .insert(knowledgeTagRelation)
+    .values({
+      knowledgeId,
+      tagId,
+    })
+    .execute();
+
+  return { success: true };
+}
+
+/**
+ * 移除知识库内容的标签
+ */
+export async function removeTagFromKnowledge(knowledgeId: number, tagId: number) {
+  const db = getDB();
+
+  await db
+    .delete(knowledgeTagRelation)
+    .where(and(eq(knowledgeTagRelation.knowledgeId, knowledgeId), eq(knowledgeTagRelation.tagId, tagId)))
+    .execute();
+
+  return { success: true };
+}
+
+/**
+ * 获取知识库内容的标签列表
+ */
+export async function getKnowledgeTags(knowledgeId: number) {
+  const db = getDB();
+
+  return await db
+    .select({
+      id: knowledgeTag.id,
+      name: knowledgeTag.name,
+      color: knowledgeTag.color,
+    })
+    .from(knowledgeTagRelation)
+    .innerJoin(knowledgeTag, eq(knowledgeTagRelation.tagId, knowledgeTag.id))
+    .where(eq(knowledgeTagRelation.knowledgeId, knowledgeId))
+    .execute();
+}
+
+/**
+ * 按标签查询知识库内容
+ */
+export async function getKnowledgeByTag(
+  tagId: number,
+  options: {
+    pageIndex?: number;
+    pageSize?: number;
+    safe?: number[];
+    userId?: number;
+    isAdmin?: boolean;
+  }
+) {
+  const db = getDB();
+  const { pageIndex = 1, pageSize = 10, safe = [0], userId, isAdmin } = options;
+
+  // 获取带有该标签的知识库 ID 列表
+  const relations = await db.select().from(knowledgeTagRelation).where(eq(knowledgeTagRelation.tagId, tagId)).execute();
+
+  if (relations.length === 0) {
+    return { list: [], total: 0, pageIndex, pageSize };
+  }
+
+  const knowledgeIds = relations.map((r) => r.knowledgeId);
+
+  let conditions = [eq(knowledge.isDelete, 0), inArray(knowledge.id, knowledgeIds)];
+
+  // 权限筛选
+  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,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["**/*.ts"]
+}

package/types/index.ts

@@ -0,0 +1,85 @@
+import type { knowledge } from "../orm/Knowledge.schema";
+import type { knowledgeTag } from "../orm/Tag.schema";
+
+// ==================== 枚举类型 ====================
+
+/**
+ * 安全级别
+ */
+export enum KnowledgeSafe {
+  PUB = 0,      // 公开（所有人可见）
+  SHARED = 1,   // 登录共享（登录用户可见）
+  PRIVATE = 2,  // 个人私密（仅创建者可见）
+}
+
+/**
+ * 节点类型
+ */
+export enum KnowledgeType {
+  FOLDER = 0,   // 文件夹
+  NOTE = 1,     // 笔记
+  BOOK = 2,     // 书籍
+}
+
+// ==================== 接口类型 ====================
+
+/**
+ * 知识库基础信息
+ */
+export interface Knowledge {
+  id: number;
+  name: string;
+  path: string;
+  level: number;
+  type: KnowledgeType;
+  safe: KnowledgeSafe;
+  userId: number;
+  // 书籍特有字段
+  coverImage?: string | null;
+  author?: string | null;
+  isbn?: string | null;
+  description?: string | null;
+  created: Date;
+  updated: Date;
+  isDelete: number;
+  isTop: number;
+  content?: string | null;
+  contentText?: string | null;
+  viewType: number;
+}
+
+/**
+ * 树节点（带子节点）
+ */
+export interface KnowledgeTreeNode extends Knowledge {
+  children?: KnowledgeTreeNode[];
+}
+
+/**
+ * 标签
+ */
+export interface KnowledgeTag {
+  id: number;
+  name: string;
+  color?: string | null;
+  userId?: number | null;
+  created?: Date;
+}
+
+/**
+ * 标签关联
+ */
+export interface KnowledgeTagRelation {
+  knowledgeId: number;
+  tagId: number;
+}
+
+/**
+ * 创建知识库输入
+ */
+export type InsertKnowledge = Partial<Omit<typeof knowledge.$inferInsert, "id">>;
+
+/**
+ * 插入标签输入
+ */
+export type InsertTag = typeof knowledgeTag.$inferInsert;

package/utils/path-builder.ts

@@ -0,0 +1,47 @@
+/**
+ * 物化路径工具函数
+ */
+
+/**
+ * 构建新节点路径
+ * @param parentPath 父节点路径
+ * @param id 新节点ID
+ * @returns 新节点路径
+ */
+export function buildPath(parentPath: string, id: number): string {
+  return `${parentPath}${id}/`;
+}
+
+/**
+ * 从路径计算层级
+ * @param path 节点路径
+ * @returns 层级深度（根节点为0）
+ */
+export function getLevel(path: string): number {
+  // path 格式: "/1/3/7/" -> 分割后 ['', '1', '3', '7', '']
+  // 减2是因为前后各有一个空字符串
+  const parts = path.split("/").filter(Boolean);
+  return parts.length - 1;
+}
+
+/**
+ * 验证路径是否有效（防止循环引用）
+ * @param newPath 新路径
+ * @param oldPath 旧路径
+ * @returns 是否有效
+ */
+export function validatePath(newPath: string, oldPath: string): boolean {
+  // 不能将节点移动到自己的后代节点下
+  // 如果新父节点的 path 以旧节点的 path 开头，说明是后代
+  return !newPath.startsWith(oldPath);
+}
+
+/**
+ * 检查是否为后代节点
+ * @param ancestorPath 祖先节点路径
+ * @param descendantPath 后代节点路径
+ * @returns 是否为后代
+ */
+export function isDescendant(ancestorPath: string, descendantPath: string): boolean {
+  return descendantPath.startsWith(ancestorPath) && ancestorPath !== descendantPath;
+}

package/utils/tree-builder.ts

@@ -0,0 +1,57 @@
+import type { KnowledgeTreeNode, Knowledge } from "../types";
+
+/**
+ * 将扁平数组转换为树形结构
+ * @param nodes 扁平节点数组
+ * @param parentId 父节点ID（可选，用于构建子树）
+ * @returns 树形结构
+ */
+export function buildTree(
+  nodes: Knowledge[],
+  parentId: number | null = null
+): KnowledgeTreeNode[] {
+  // 按 isTop 降序、created 降序排序
+  const sortedNodes = [...nodes].sort((a, b) => {
+    if (a.isTop !== b.isTop) {
+      return b.isTop - a.isTop;
+    }
+    return b.created.getTime() - a.created.getTime();
+  });
+
+  // 如果指定了 parentId，先找到该节点
+  if (parentId !== null) {
+    const parent = sortedNodes.find(n => n.id === parentId);
+    if (!parent) return [];
+
+    // 查找该节点的直接子节点
+    const children = sortedNodes.filter(n =>
+      n.path.startsWith(parent.path) &&
+      n.level === parent.level + 1
+    );
+
+    return children.map(child => buildNodeTree(child, sortedNodes));
+  }
+
+  // 否则返回根节点（level=0）的树
+  const rootNodes = sortedNodes.filter(n => n.level === 0);
+  return rootNodes.map(node => buildNodeTree(node, sortedNodes));
+}
+
+/**
+ * 递归构建节点树
+ */
+function buildNodeTree(node: Knowledge, allNodes: Knowledge[]): KnowledgeTreeNode {
+  const treeNode: KnowledgeTreeNode = { ...node };
+
+  // 查找直接子节点
+  const children = allNodes.filter(n =>
+    n.path.startsWith(node.path) &&
+    n.level === node.level + 1
+  );
+
+  if (children.length > 0) {
+    treeNode.children = children.map(child => buildNodeTree(child, allNodes));
+  }
+
+  return treeNode;
+}

package/zod/knowledge.schema.ts

@@ -0,0 +1,13 @@
+// Zod 验证 Schema 已在 orm/Knowledge.schema.ts 中定义
+// 此文件导出所有知识库相关的 Schema
+export {
+  createKnowledgeSchema,
+  batchCreateKnowledgeSchema,
+  batchDetailKnowledgeSchema,
+  updateKnowledgeSchema,
+  listKnowledgeSchema,
+  searchKnowledgeSchema,
+  moveKnowledgeSchema,
+  updateIsTopSchema,
+  updateSafeSchema,
+} from "../orm/Knowledge.schema";

package/zod/tag.schema.ts

@@ -0,0 +1,7 @@
+// Zod 验证 Schema 已在 orm/Tag.schema.ts 中定义
+// 此文件导出所有标签相关的 Schema
+export {
+  createTagSchema,
+  updateTagSchema,
+  addTagRelationSchema,
+} from "../orm/Tag.schema";

package/dist/Knowledge.schema-BHFPDLIO.mjs

@@ -1,27 +0,0 @@
-import {
-  batchCreateKnowledgeSchema,
-  batchDetailKnowledgeSchema,
-  createKnowledgeSchema,
-  knowledge,
-  listKnowledgeSchema,
-  moveKnowledgeSchema,
-  searchKnowledgeSchema,
-  updateIsTopSchema,
-  updateKnowledgeSchema,
-  updateSafeSchema
-} from "./chunk-2G44ILZL.mjs";
-import "./chunk-GWIBTASJ.mjs";
-import "./chunk-VHBDNZOQ.mjs";
-export {
-  batchCreateKnowledgeSchema,
-  batchDetailKnowledgeSchema,
-  createKnowledgeSchema,
-  knowledge,
-  listKnowledgeSchema,
-  moveKnowledgeSchema,
-  searchKnowledgeSchema,
-  updateIsTopSchema,
-  updateKnowledgeSchema,
-  updateSafeSchema
-};
-//# sourceMappingURL=Knowledge.schema-BHFPDLIO.mjs.map

package/dist/Knowledge.schema-BHFPDLIO.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}