@superatomai/sdk-node 0.0.23 → 0.0.24

package/dist/index.js

@@ -702,6 +702,36 @@ var BookmarksRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("BOOKMARKS"),
   payload: BookmarksRequestPayloadSchema
 });
+var KbNodesQueryFiltersSchema = import_zod3.z.object({
+  query: import_zod3.z.string().optional(),
+  category: import_zod3.z.string().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+  createdBy: import_zod3.z.number().optional()
+});
+var KbNodesRequestPayloadSchema = import_zod3.z.object({
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "search", "getByCategory", "getByUser", "getCategories", "getTags"]),
+  data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
+    title: import_zod3.z.string().optional(),
+    content: import_zod3.z.string().optional(),
+    category: import_zod3.z.string().optional(),
+    tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+    createdBy: import_zod3.z.number().optional(),
+    updatedBy: import_zod3.z.number().optional(),
+    userId: import_zod3.z.number().optional(),
+    // Query/search operation fields
+    query: import_zod3.z.string().optional(),
+    filters: KbNodesQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    offset: import_zod3.z.number().optional()
+  }).optional()
+});
+var KbNodesRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("KB_NODES"),
+  payload: KbNodesRequestPayloadSchema
+});
 
 // src/utils/logger.ts
 var import_fs = __toESM(require("fs"));
@@ -7885,6 +7915,458 @@ function sendResponse7(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
+// src/handlers/kb-nodes.ts
+async function handleKbNodesRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      throw new Error(`Collection '${collection}' or operation '${op}' not found`);
+    }
+    return await handler(params);
+  };
+  try {
+    const request = KbNodesRequestMessageSchema.parse(data);
+    const { id, payload, from } = request;
+    const { operation, data: requestData } = payload;
+    const nodeId = requestData?.id;
+    const title = requestData?.title;
+    const content = requestData?.content;
+    const category = requestData?.category;
+    const tags = requestData?.tags;
+    const createdBy = requestData?.createdBy;
+    const updatedBy = requestData?.updatedBy;
+    const userId = requestData?.userId;
+    const query = requestData?.query;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const offset = requestData?.offset;
+    switch (operation) {
+      case "create":
+        await handleCreate6(id, { title, content, category, tags, createdBy }, executeCollection, sendMessage, from.id);
+        break;
+      case "update":
+        await handleUpdate6(id, nodeId, { title, content, category, tags, updatedBy }, executeCollection, sendMessage, from.id);
+        break;
+      case "delete":
+        await handleDelete6(id, nodeId, executeCollection, sendMessage, from.id);
+        break;
+      case "getAll":
+        await handleGetAll6(id, limit, offset, executeCollection, sendMessage, from.id);
+        break;
+      case "getOne":
+        await handleGetOne6(id, nodeId, executeCollection, sendMessage, from.id);
+        break;
+      case "search":
+        await handleSearch(id, { query, category, tags, createdBy, limit, offset }, executeCollection, sendMessage, from.id);
+        break;
+      case "getByCategory":
+        await handleGetByCategory(id, category, limit, offset, executeCollection, sendMessage, from.id);
+        break;
+      case "getByUser":
+        await handleGetByUser(id, userId, limit, offset, executeCollection, sendMessage, from.id);
+        break;
+      case "getCategories":
+        await handleGetCategories(id, executeCollection, sendMessage, from.id);
+        break;
+      case "getTags":
+        await handleGetTags(id, executeCollection, sendMessage, from.id);
+        break;
+      default:
+        sendResponse8(id, {
+          success: false,
+          error: `Unknown operation: ${operation}`
+        }, sendMessage, from.id);
+    }
+  } catch (error) {
+    logger.error("Failed to handle KB nodes request:", error);
+    sendResponse8(null, {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    }, sendMessage);
+  }
+}
+async function handleCreate6(id, nodeData, executeCollection, sendMessage, clientId) {
+  const { title, content, category, tags, createdBy } = nodeData;
+  if (!title || title.trim().length === 0) {
+    sendResponse8(id, {
+      success: false,
+      error: "Title is required and cannot be empty"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!content || content.trim().length === 0) {
+    sendResponse8(id, {
+      success: false,
+      error: "Content is required and cannot be empty"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!createdBy) {
+    sendResponse8(id, {
+      success: false,
+      error: "createdBy (user ID) is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "create", {
+      title,
+      content,
+      category: category || void 0,
+      tags: tags || void 0,
+      createdBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] KB node created successfully: ${title}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          ...result.data,
+          message: `Knowledge node '${title}' created successfully`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to create knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to create KB node:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to create knowledge node"
+    }, sendMessage, clientId);
+  }
+}
+async function handleUpdate6(id, nodeId, nodeData, executeCollection, sendMessage, clientId) {
+  const { title, content, category, tags, updatedBy } = nodeData;
+  if (!nodeId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Knowledge node ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!updatedBy) {
+    sendResponse8(id, {
+      success: false,
+      error: "updatedBy (user ID) is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "update", {
+      id: nodeId,
+      title,
+      content,
+      category,
+      tags,
+      updatedBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] KB node updated successfully, ID: ${nodeId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          ...result.data,
+          message: `Knowledge node updated successfully`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to update knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to update KB node:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update knowledge node"
+    }, sendMessage, clientId);
+  }
+}
+async function handleDelete6(id, nodeId, executeCollection, sendMessage, clientId) {
+  if (!nodeId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Knowledge node ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "delete", { id: nodeId });
+    if (result && result.success) {
+      logger.info(`[DB] KB node deleted successfully, ID: ${nodeId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          id: nodeId,
+          ...result.data,
+          message: `Knowledge node deleted successfully`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to delete knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to delete KB node:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to delete knowledge node"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetAll6(id, limit, offset, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("kbNodes", "getAll", {
+      limit: limit || 100,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} KB nodes`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} knowledge nodes`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve knowledge nodes"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get all KB nodes:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetOne6(id, nodeId, executeCollection, sendMessage, clientId) {
+  if (!nodeId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Knowledge node ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "getOne", { id: nodeId });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved KB node ID: ${nodeId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          node: result.data,
+          message: `Retrieved knowledge node`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get KB node:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge node"
+    }, sendMessage, clientId);
+  }
+}
+async function handleSearch(id, searchParams, executeCollection, sendMessage, clientId) {
+  const { query, category, tags, createdBy, limit, offset } = searchParams;
+  try {
+    const result = await executeCollection("kbNodes", "search", {
+      query,
+      category,
+      tags,
+      createdBy,
+      limit: limit || 50,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Search returned ${result.count} KB nodes`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          message: `Search returned ${result.count} knowledge nodes`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to search knowledge nodes"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to search KB nodes:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to search knowledge nodes"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetByCategory(id, category, limit, offset, executeCollection, sendMessage, clientId) {
+  if (!category) {
+    sendResponse8(id, {
+      success: false,
+      error: "Category is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "getByCategory", {
+      category,
+      limit: limit || 50,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} KB nodes for category: ${category}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          category,
+          message: `Retrieved ${result.count} knowledge nodes for category '${category}'`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve knowledge nodes by category"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get KB nodes by category:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes by category"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetByUser(id, userId, limit, offset, executeCollection, sendMessage, clientId) {
+  if (!userId) {
+    sendResponse8(id, {
+      success: false,
+      error: "User ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "getByUser", {
+      userId,
+      limit: limit || 50,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} KB nodes for user: ${userId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          userId,
+          message: `Retrieved ${result.count} knowledge nodes for user ${userId}`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve knowledge nodes by user"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get KB nodes by user:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes by user"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetCategories(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("kbNodes", "getCategories", {});
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} categories`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          categories: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} categories`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve categories"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get categories:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve categories"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetTags(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("kbNodes", "getTags", {});
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} tags`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          tags: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} tags`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve tags"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get tags:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve tags"
+    }, sendMessage, clientId);
+  }
+}
+function sendResponse8(id, res, sendMessage, clientId) {
+  const response = {
+    id: id || "unknown",
+    type: "KB_NODES_RES",
+    from: { type: "data-agent" },
+    to: {
+      type: "admin",
+      id: clientId
+    },
+    payload: {
+      ...res
+    }
+  };
+  sendMessage(response);
+}
+
 // src/auth/user-manager.ts
 var import_fs4 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
@@ -8914,6 +9396,11 @@ var SuperatomSDK = class {
             logger.error("Failed to handle bookmarks request:", error);
           });
           break;
+        case "KB_NODES":
+          handleKbNodesRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
+            logger.error("Failed to handle KB nodes request:", error);
+          });
+          break;
         default:
           const handler = this.messageTypeHandlers.get(message.type);
           if (handler) {