@mindbase/express-knowledge 1.0.4 → 1.0.8

package/index.ts

@@ -0,0 +1,35 @@
+export { default } from "./module/KnowledgeModule";
+
+// 导出类型
+export {
+  type KnowledgeSafe,
+  type KnowledgeType,
+  type Knowledge,
+  type KnowledgeTreeNode,
+  type KnowledgeTag,
+  type KnowledgeTagRelation,
+  type InsertKnowledge,
+  type InsertTag,
+} from './types';
+
+// 导出 Schema
+export {
+  knowledge,
+  createKnowledgeSchema,
+  batchCreateKnowledgeSchema,
+  batchDetailKnowledgeSchema,
+  updateKnowledgeSchema,
+  listKnowledgeSchema,
+  searchKnowledgeSchema,
+  moveKnowledgeSchema,
+  updateIsTopSchema,
+  updateSafeSchema,
+} from './orm/Knowledge.schema';
+
+export {
+  knowledgeTag,
+  knowledgeTagRelation,
+  createTagSchema,
+  updateTagSchema,
+  addTagRelationSchema,
+} from './orm/Tag.schema';

package/module/KnowledgeModule.ts

@@ -0,0 +1,18 @@
+import { createModule } from "@mindbase/express-common";
+import { logger } from "@mindbase/express-common";
+
+export default createModule(async (app) => {
+  const db = app.getDB();
+
+  logger.info("[KnowledgeModule] 初始化 knowledge 模块");
+
+  // 初始化 Service
+  const { initKnowledgeService } = await import("../service/KnowledgeService");
+  const { initTagService } = await import("../service/TagService");
+  initKnowledgeService(db);
+  initTagService(db);
+
+  // 路由将通过自动扫描 routes/*.route.ts 和 routes/**/*.route.ts 注册
+
+  logger.info("[KnowledgeModule] 模块加载完成");
+}, __filename);

package/orm/Knowledge.schema.ts

@@ -0,0 +1,123 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+
+/**
+ * 知识库主表
+ */
+export const knowledge = sqliteTable("knowledge", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  parentId: integer("parent_id").notNull(),
+  name: text("name").notNull(),
+  path: text("path").notNull(),
+  level: integer("level").notNull().default(0),
+  type: integer("type").notNull(), // 0:文件夹 1:笔记 2:书籍
+  safe: integer("safe").notNull().default(0),
+  userId: integer("user_id").notNull(),
+  // 书籍特有字段
+  coverImage: text("cover_image"),
+  author: text("author"),
+  isbn: text("isbn"),
+  description: text("description"),
+  created: integer("created", { mode: "timestamp" }),
+  updated: integer("updated", { mode: "timestamp" }),
+  isDelete: integer("is_delete").notNull().default(0),
+  isTop: integer("is_top").notNull().default(0),
+  content: text("content"),
+  contentText: text("content_text"),
+  viewType: integer("view_type").default(0),
+});
+
+// ==================== Zod Schemas ====================
+
+/**
+ * 创建知识库内容验证
+ */
+export const createKnowledgeSchema = createInsertSchema(knowledge as any, {
+  name: z.string().min(1, "名称不能为空").max(255, "名称不能超过255字符") as any,
+  type: z.coerce.number().int().min(0).max(2) as any,
+  safe: z.coerce.number().int().min(0).max(2).optional() as any,
+}).pick({
+  name: true,
+  type: true,
+  safe: true,
+  description: true,
+  content: true,
+  contentText: true,
+  viewType: true,
+  coverImage: true,
+  author: true,
+  isbn: true,
+});
+
+/**
+ * 批量创建验证
+ */
+export const batchCreateKnowledgeSchema = z.object({
+  parentId: z.number().optional(),
+  items: z
+    .array(
+      z.object({
+        name: z.string().min(1, "名称不能为空").max(255),
+        type: z.coerce.number().int().min(0).max(2),
+      })
+    )
+    .min(1, "至少需要一个项目"),
+});
+
+/**
+ * 批量获取详情验证
+ */
+export const batchDetailKnowledgeSchema = z.object({
+  ids: z.array(z.number().int().positive()).min(1, "至少需要一个ID"),
+});
+
+/**
+ * 更新知识库内容验证
+ */
+export const updateKnowledgeSchema = createInsertSchema(knowledge as any)
+  .partial()
+  .extend({
+    id: z.number({ required_error: "ID不能为空" }),
+  });
+
+/**
+ * 列表查询验证
+ */
+export const listKnowledgeSchema = z.object({
+  pageIndex: z.coerce.number().int().positive().optional().default(1),
+  pageSize: z.coerce.number().int().positive().optional().default(10),
+  level: z.coerce.number().int().min(0).optional(),
+  type: z.coerce.number().int().min(0).max(2).optional(),
+  safe: z.array(z.coerce.number().int().min(0).max(2)).optional(),
+});
+
+/**
+ * 搜索验证
+ */
+export const searchKnowledgeSchema = z.object({
+  keyword: z.string().min(1, "关键词不能为空"),
+  pageIndex: z.coerce.number().int().positive().optional().default(1),
+  pageSize: z.coerce.number().int().positive().optional().default(10),
+});
+
+/**
+ * 移动节点验证
+ */
+export const moveKnowledgeSchema = z.object({
+  newParentId: z.number({ required_error: "新父节点ID不能为空" }),
+});
+
+/**
+ * 更新置顶状态验证
+ */
+export const updateIsTopSchema = z.object({
+  isTop: z.coerce.number().int().min(0).max(1),
+});
+
+/**
+ * 更新安全等级验证
+ */
+export const updateSafeSchema = z.object({
+  safe: z.coerce.number().int().min(0).max(2),
+});

package/orm/Tag.schema.ts

@@ -0,0 +1,51 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+
+/**
+ * 标签表
+ */
+export const knowledgeTag = sqliteTable("knowledge_tag", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  name: text("name").notNull().unique(),
+  color: text("color"),
+  userId: integer("user_id"),
+  created: integer("created", { mode: "timestamp" }),
+});
+
+/**
+ * 标签关联表（多对多）
+ */
+export const knowledgeTagRelation = sqliteTable("knowledge_tag_relation", {
+  knowledgeId: integer("knowledge_id").notNull(),
+  tagId: integer("tag_id").notNull(),
+});
+
+// ==================== Zod Schemas ====================
+
+/**
+ * 创建标签验证
+ */
+export const createTagSchema = createInsertSchema(knowledgeTag as any, {
+  name: z.string().min(1, "标签名不能为空").max(50, "标签名不能超过50字符") as any,
+  color: z.string().regex(/^#[0-9A-Fa-f]{6}$/, "颜色必须是十六进制格式").optional() as any,
+}).pick({
+  name: true,
+  color: true,
+});
+
+/**
+ * 更新标签验证
+ */
+export const updateTagSchema = createInsertSchema(knowledgeTag as any)
+  .partial()
+  .extend({
+    id: z.number({ required_error: "标签ID不能为空" }),
+  });
+
+/**
+ * 添加标签关联验证
+ */
+export const addTagRelationSchema = z.object({
+  tagId: z.number({ required_error: "标签ID不能为空" }),
+});

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@mindbase/express-knowledge",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "exports": {
-    ".": {
-      "development": "./index.ts",
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
-    }
+    ".": "./index.ts"
   },
   "files": [
-    "dist"
+    "routes",
+    "zod",
+    "orm",
+    "module",
+    "service",
+    "utils",
+    "types",
+    "index.ts",
+    "tsconfig.json"
   ],
   "engines": {
     "node": ">=20.0.0"
@@ -21,11 +25,10 @@
     "zod": "^3.24.0"
   },
   "devDependencies": {
-    "tsup": "^8.0.0",
     "typescript": "^5.1.3"
   },
   "scripts": {
-    "prepublishOnly": "tsup"
+    "prepare": "tsc --noEmit"
   },
   "publishConfig": {
     "access": "public"

package/routes/knowledge/tags.route.ts

@@ -0,0 +1,192 @@
+import { Router, type Request, type Response, type NextFunction } from "express";
+import { logger, validate } from "@mindbase/express-common";
+import * as TagService from "../../service/TagService";
+import * as schemas from "../../zod/tag.schema";
+
+const router = Router();
+
+// ==================== 标签路由 ====================
+
+/**
+ * 获取标签列表
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {Object[]} data 标签列表
+ */
+router.get("/", async (req: Request, res: Response, next: NextFunction) => {
+  const userId = res.locals.user?.id;
+
+  try {
+    const tags = await TagService.listTags(userId);
+    res.json({ code: 200, message: "获取成功", data: tags });
+  } catch (error) {
+    logger.error("[TagRoute] 获取标签列表失败:", error);
+    next(error);
+  }
+});
+
+/**
+ * 创建标签
+ * @apiParam {string} name 标签名称（必填）
+ * @apiParam {string} [color] 颜色（可选）
+ * @apiParam {string} [description] 描述（可选）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {Object} data 创建的标签信息
+ */
+router.post("/", validate(schemas.createTagSchema), async (req: Request, res: Response, next: NextFunction) => {
+  const userId = res.locals.user?.id;
+
+  try {
+    const result = await TagService.createTag({
+      ...req.body,
+      userId,
+    });
+    res.json({ code: 200, message: "创建成功", data: result });
+  } catch (error) {
+    logger.error("[TagRoute] 创建标签失败:", error);
+    next(error);
+  }
+});
+
+/**
+ * 更新标签
+ * @apiParam {number} id 标签ID（路径参数，必填）
+ * @apiParam {string} [name] 标签名称（可选）
+ * @apiParam {string} [color] 颜色（可选）
+ * @apiParam {string} [description] 描述（可选）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {Object} data 更新后的标签信息
+ */
+router.post("/:id", validate(schemas.updateTagSchema), async (req: Request, res: Response, next: NextFunction) => {
+  const { id } = req.params;
+  const userId = res.locals.user?.id;
+
+  try {
+    const result = await TagService.updateTag(Number(id), req.body, userId);
+    res.json({ code: 200, message: "更新成功", data: result });
+  } catch (error) {
+    logger.error("[TagRoute] 更新标签失败:", error);
+    next(error);
+  }
+});
+
+/**
+ * 删除标签
+ * @apiParam {number} id 标签ID（路径参数，必填）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {null} data 返回空
+ */
+router.delete("/:id", async (req: Request, res: Response, next: NextFunction) => {
+  const { id } = req.params;
+  const userId = res.locals.user?.id;
+
+  try {
+    await TagService.deleteTag(Number(id), userId);
+    res.json({ code: 200, message: "删除成功", data: null });
+  } catch (error) {
+    logger.error("[TagRoute] 删除标签失败:", error);
+    next(error);
+  }
+});
+
+/**
+ * 为知识库内容添加标签
+ * @apiParam {number} id 内容ID（路径参数，必填）
+ * @apiParam {number} tagId 标签ID（必填）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {Object} data 添加结果
+ */
+router.post(
+  "/:id/tags",
+  validate(schemas.addTagRelationSchema),
+  async (req: Request, res: Response, next: NextFunction) => {
+    const { id } = req.params;
+    const { tagId } = req.body;
+    const userId = res.locals.user?.id;
+
+    try {
+      const result = await TagService.addTagToKnowledge(Number(id), tagId, userId);
+      res.json({ code: 200, message: "添加成功", data: result });
+    } catch (error) {
+      logger.error("[TagRoute] 添加标签失败:", error);
+      next(error);
+    }
+  }
+);
+
+/**
+ * 移除知识库内容的标签
+ * @apiParam {number} id 内容ID（路径参数，必填）
+ * @apiParam {number} tagId 标签ID（路径参数，必填）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {null} data 返回空
+ */
+router.delete("/:id/tags/:tagId", async (req: Request, res: Response, next: NextFunction) => {
+  const { id, tagId } = req.params;
+
+  try {
+    await TagService.removeTagFromKnowledge(Number(id), Number(tagId));
+    res.json({ code: 200, message: "移除成功", data: null });
+  } catch (error) {
+    logger.error("[TagRoute] 移除标签失败:", error);
+    next(error);
+  }
+});
+
+/**
+ * 获取知识库内容的标签列表
+ * @apiParam {number} id 内容ID（路径参数，必填）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {Object[]} data 标签列表
+ */
+router.get("/:id/tags", async (req: Request, res: Response, next: NextFunction) => {
+  const { id } = req.params;
+
+  try {
+    const tags = await TagService.getKnowledgeTags(Number(id));
+    res.json({ code: 200, message: "获取成功", data: tags });
+  } catch (error) {
+    logger.error("[TagRoute] 获取内容标签失败:", error);
+    next(error);
+  }
+});
+
+/**
+ * 按标签查询知识库内容
+ * @apiParam {number} tagId 标签ID（路径参数，必填）
+ * @apiParam {number} [pageIndex] 页码（可选，默认1）
+ * @apiParam {number} [pageSize] 每页数量（可选，默认10）
+ * @apiSuccess {number} code 状态码
+ * @apiSuccess {string} message 消息
+ * @apiSuccess {Object} data 查询结果
+ * @apiSuccess {Object[]} data.list 内容列表
+ * @apiSuccess {number} data.total 总数
+ */
+router.get("/by-tag/:tagId", async (req: Request, res: Response, next: NextFunction) => {
+  const { tagId } = req.params;
+  const userId = res.locals.user?.id;
+  const permissions = res.locals.permissions || [];
+  const isAdmin = permissions.includes("admin") || permissions.includes("*:*:*");
+  const { pageIndex, pageSize } = req.query;
+
+  try {
+    const result = await TagService.getKnowledgeByTag(Number(tagId), {
+      pageIndex: pageIndex ? Number(pageIndex) : 1,
+      pageSize: pageSize ? Number(pageSize) : 10,
+      userId,
+      isAdmin,
+    });
+    res.json({ code: 200, message: "获取成功", data: result });
+  } catch (error) {
+    logger.error("[TagRoute] 按标签查询失败:", error);
+    next(error);
+  }
+});
+
+export default router;