@mindbase/express-knowledge 1.0.12 → 1.0.13

package/types/index.ts

@@ -1,85 +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;
+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

@@ -1,47 +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;
-}
+/**
+ * 物化路径工具函数
+ */
+
+/**
+ * 构建新节点路径
+ * @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

@@ -1,57 +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;
-}
+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;
+}