@superatomai/sdk-web 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -188,7 +188,7 @@ var DSLRendererPropsSchema2 = zod.z.object({
   context: zod.z.record(zod.z.string(), zod.z.any()).optional()
 });
 
-// src/schemas.ts
+// src/types.ts
 var MessageParticipantSchema = zod.z.object({
   id: zod.z.string().optional(),
   type: zod.z.string().optional()
@@ -431,14 +431,25 @@ var ComponentsSendMessageSchema = zod.z.object({
   to: MessageParticipantSchema.optional(),
   payload: ComponentsSendPayloadSchema
 });
+var UserQueryFiltersSchema = zod.z.object({
+  username: zod.z.string().optional(),
+  email: zod.z.string().optional(),
+  role: zod.z.string().optional(),
+  fullname: zod.z.string().optional()
+});
 var UsersRequestPayloadSchema = zod.z.object({
-  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: zod.z.object({
+    id: zod.z.number().optional(),
     username: zod.z.string().optional(),
     email: zod.z.string().email("Invalid email format").optional(),
     password: zod.z.string().optional(),
     fullname: zod.z.string().optional(),
-    role: zod.z.string().optional()
+    role: zod.z.string().optional(),
+    // Query operation fields
+    filters: UserQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var UsersRequestMessageSchema = zod.z.object({
@@ -649,15 +660,24 @@ var BookmarkDataSchema = zod.z.object({
   created_at: zod.z.string().optional(),
   updated_at: zod.z.string().optional()
 });
+var BookmarkQueryFiltersSchema = zod.z.object({
+  userId: zod.z.number().optional(),
+  threadId: zod.z.string().optional(),
+  name: zod.z.string().optional()
+});
 var BookmarksRequestPayloadSchema = zod.z.object({
-  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread"]),
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: zod.z.object({
     id: zod.z.number().optional(),
     userId: zod.z.number().optional(),
     threadId: zod.z.string().optional(),
     name: zod.z.string().optional(),
     description: zod.z.string().optional(),
-    uiblock: DBUIBlockSchema.optional()
+    uiblock: DBUIBlockSchema.optional(),
+    // Query operation fields
+    filters: BookmarkQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var BookmarksRequestMessageSchema = zod.z.object({
@@ -684,6 +704,82 @@ zod.z.object({
   to: MessageParticipantSchema.optional(),
   payload: BookmarksResponsePayloadSchema
 });
+var KbNodeDataSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  title: zod.z.string(),
+  content: zod.z.string(),
+  category: zod.z.string().nullable().optional(),
+  tags: zod.z.array(zod.z.string()).nullable().optional(),
+  createdBy: zod.z.number(),
+  updatedBy: zod.z.number().optional(),
+  createdAt: zod.z.string().optional(),
+  updatedAt: zod.z.string().optional()
+});
+var KbNodesQueryFiltersSchema = zod.z.object({
+  query: zod.z.string().optional(),
+  category: zod.z.string().optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  createdBy: zod.z.number().optional()
+});
+var KbNodesRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "search", "getByCategory", "getByUser", "getCategories", "getTags"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    title: zod.z.string().optional(),
+    content: zod.z.string().optional(),
+    category: zod.z.string().optional(),
+    tags: zod.z.array(zod.z.string()).optional(),
+    createdBy: zod.z.number().optional(),
+    updatedBy: zod.z.number().optional(),
+    userId: zod.z.number().optional(),
+    // Query/search operation fields
+    query: zod.z.string().optional(),
+    filters: KbNodesQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    offset: zod.z.number().optional()
+  }).optional()
+});
+var KbNodesRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("KB_NODES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: KbNodesRequestPayloadSchema
+});
+var KbNodesResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    // Single node operations
+    id: zod.z.number().optional(),
+    title: zod.z.string().optional(),
+    content: zod.z.string().optional(),
+    category: zod.z.string().nullable().optional(),
+    tags: zod.z.array(zod.z.string()).nullable().optional(),
+    createdBy: zod.z.number().optional(),
+    updatedBy: zod.z.number().optional(),
+    createdAt: zod.z.string().optional(),
+    updatedAt: zod.z.string().optional(),
+    message: zod.z.string().optional(),
+    // GetOne response
+    node: KbNodeDataSchema.optional(),
+    // List operations
+    nodes: zod.z.array(KbNodeDataSchema).optional(),
+    count: zod.z.number().optional(),
+    // getByCategory/getByUser
+    userId: zod.z.number().optional(),
+    // getCategories
+    categories: zod.z.array(zod.z.string()).optional()
+    // getTags
+  }).optional()
+});
+var KbNodesResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("KB_NODES_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: KbNodesResponsePayloadSchema
+});
 var ClientConfigSchema = zod.z.object({
   userId: zod.z.string(),
   projectId: zod.z.string(),
@@ -708,33 +804,42 @@ __export(services_exports, {
   UIElementSchema: () => UIElementSchema,
   createBookmark: () => createBookmark,
   createDashboard: () => createDashboard,
+  createKbNode: () => createKbNode,
   createReport: () => createReport,
   createUI: () => createUI,
   createUser: () => createUser,
   deleteBookmark: () => deleteBookmark,
   deleteDashboard: () => deleteDashboard,
+  deleteKbNode: () => deleteKbNode,
   deleteReport: () => deleteReport,
   deleteUI: () => deleteUI,
   deleteUser: () => deleteUser,
   getActions: () => getActions,
   getAllBookmarks: () => getAllBookmarks,
   getAllDashboards: () => getAllDashboards,
+  getAllKbNodes: () => getAllKbNodes,
   getAllReports: () => getAllReports,
   getAllUIs: () => getAllUIs,
   getAllUsers: () => getAllUsers,
   getBookmark: () => getBookmark,
-  getBookmarksByThread: () => getBookmarksByThread,
-  getBookmarksByUser: () => getBookmarksByUser,
   getComponentSuggestions: () => getComponentSuggestions,
   getDashboard: () => getDashboard,
+  getKbNode: () => getKbNode,
+  getKbNodeCategories: () => getKbNodeCategories,
+  getKbNodeTags: () => getKbNodeTags,
+  getKbNodesByCategory: () => getKbNodesByCategory,
+  getKbNodesByUser: () => getKbNodesByUser,
   getReport: () => getReport,
   getUI: () => getUI,
   getUser: () => getUser,
+  queryBookmarks: () => queryBookmarks,
   queryDashboards: () => queryDashboards,
   queryReports: () => queryReports,
   queryUIs: () => queryUIs,
+  queryUsers: () => queryUsers,
   requestBundle: () => requestBundle,
   requestData: () => requestData,
+  searchKbNodes: () => searchKbNodes,
   sendAuthLoginRequest: () => sendAuthLoginRequest,
   sendAuthVerifyRequest: () => sendAuthVerifyRequest,
   sendComponents: () => sendComponents,
@@ -742,6 +847,7 @@ __export(services_exports, {
   sendUserPromptSuggestionsRequest: () => sendUserPromptSuggestionsRequest,
   updateBookmark: () => updateBookmark,
   updateDashboard: () => updateDashboard,
+  updateKbNode: () => updateKbNode,
   updateReport: () => updateReport,
   updateUI: () => updateUI,
   updateUser: () => updateUser
@@ -1086,6 +1192,33 @@ async function getUser(client, username, timeout) {
     message: payload.data?.message
   };
 }
+async function queryUsers(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `users_query_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    users: payload.data?.users,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
 
 // src/services/dashboards/index.ts
 async function createDashboard(client, options, timeout) {
@@ -1531,42 +1664,20 @@ async function getBookmark(client, id, timeout) {
     message: payload.message
   };
 }
-async function getBookmarksByUser(client, userId, threadId, timeout) {
-  const messageId = `bookmarks_getbyuser_${Date.now()}`;
-  const message = BookmarksRequestMessageSchema.parse({
-    id: messageId,
-    type: "BOOKMARKS",
-    from: { type: client.type },
-    to: { type: "data-agent" },
-    payload: {
-      operation: "getByUser",
-      data: {
-        userId,
-        threadId
-      }
-    }
-  });
-  const response = await client.sendWithResponse(message, timeout);
-  const payload = response.payload;
-  return {
-    success: payload.success,
-    error: payload.error,
-    data: Array.isArray(payload.data) ? payload.data : payload.data ? [payload.data] : [],
-    count: payload.count,
-    message: payload.message
-  };
-}
-async function getBookmarksByThread(client, threadId, timeout) {
-  const messageId = `bookmarks_getbythread_${Date.now()}`;
+async function queryBookmarks(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `bookmarks_query_${Date.now()}`;
   const message = BookmarksRequestMessageSchema.parse({
     id: messageId,
     type: "BOOKMARKS",
     from: { type: client.type },
     to: { type: "data-agent" },
     payload: {
-      operation: "getByThread",
+      operation: "query",
       data: {
-        threadId
+        filters,
+        limit,
+        sort
       }
     }
   });
@@ -1762,6 +1873,277 @@ async function queryUIs(client, options = {}, timeout) {
   };
 }
 
+// src/services/kb-nodes.ts
+async function createKbNode(client, title, content, createdBy, category, tags, timeout) {
+  const messageId = `kb_nodes_create_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        title,
+        content,
+        createdBy,
+        category,
+        tags
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    node: payload.data ? {
+      id: payload.data.id,
+      title: payload.data.title || title,
+      content: payload.data.content || content,
+      category: payload.data.category,
+      tags: payload.data.tags,
+      createdBy: payload.data.createdBy || createdBy,
+      updatedBy: payload.data.updatedBy,
+      createdAt: payload.data.createdAt,
+      updatedAt: payload.data.updatedAt
+    } : void 0
+  };
+}
+async function updateKbNode(client, id, updatedBy, updates, timeout) {
+  const messageId = `kb_nodes_update_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        updatedBy,
+        ...updates
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    node: payload.data ? {
+      id: payload.data.id,
+      title: payload.data.title || "",
+      content: payload.data.content || "",
+      category: payload.data.category,
+      tags: payload.data.tags,
+      createdBy: payload.data.createdBy || 0,
+      updatedBy: payload.data.updatedBy,
+      createdAt: payload.data.createdAt,
+      updatedAt: payload.data.updatedAt
+    } : void 0
+  };
+}
+async function deleteKbNode(client, id, timeout) {
+  const messageId = `kb_nodes_delete_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        id
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message
+  };
+}
+async function getAllKbNodes(client, limit, offset, timeout) {
+  const messageId = `kb_nodes_getall_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll",
+      data: {
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getKbNode(client, id, timeout) {
+  const messageId = `kb_nodes_getone_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        id
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    node: payload.data?.node,
+    message: payload.data?.message
+  };
+}
+async function searchKbNodes(client, options = {}, timeout) {
+  const { query, category, tags, createdBy, limit, offset } = options;
+  const messageId = `kb_nodes_search_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "search",
+      data: {
+        query,
+        category,
+        tags,
+        createdBy,
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getKbNodesByCategory(client, category, limit, offset, timeout) {
+  const messageId = `kb_nodes_getbycategory_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getByCategory",
+      data: {
+        category,
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    category: payload.data?.category || category,
+    message: payload.data?.message
+  };
+}
+async function getKbNodesByUser(client, userId, limit, offset, timeout) {
+  const messageId = `kb_nodes_getbyuser_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getByUser",
+      data: {
+        userId,
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    userId: payload.data?.userId || userId,
+    message: payload.data?.message
+  };
+}
+async function getKbNodeCategories(client, timeout) {
+  const messageId = `kb_nodes_getcategories_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getCategories"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    categories: payload.data?.categories,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getKbNodeTags(client, timeout) {
+  const messageId = `kb_nodes_gettags_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getTags"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  const responseData = payload.data;
+  return {
+    success: payload.success,
+    error: payload.error,
+    tags: responseData?.tags,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+
 // src/client.ts
 var SuperatomClient = class {
   constructor(config) {
@@ -2139,6 +2521,14 @@ var SuperatomClient = class {
     this.log("info", "Fetching user:", username);
     return getUser(this, username, timeout);
   }
+  /**
+   * Query users with filters, limit, and sort
+   * Delegates to users service
+   */
+  async queryUsers(options = {}, timeout) {
+    this.log("info", "Querying users with filters:", options.filters);
+    return queryUsers(this, options, timeout);
+  }
   // ==================== Dashboard Management Methods ====================
   // These methods delegate to dashboard service for admin dashboard CRUD operations
   /**
@@ -2232,20 +2622,12 @@ var SuperatomClient = class {
     return getBookmark(this, id, timeout);
   }
   /**
-   * Get bookmarks by user ID (and optionally by thread ID)
+   * Query bookmarks with filters, limit, and sort
    * Delegates to bookmarks service
    */
-  async getBookmarksByUser(userId, threadId, timeout) {
-    this.log("info", "Fetching bookmarks for user:", userId);
-    return getBookmarksByUser(this, userId, threadId, timeout);
-  }
-  /**
-   * Get bookmarks by thread ID
-   * Delegates to bookmarks service
-   */
-  async getBookmarksByThread(threadId, timeout) {
-    this.log("info", "Fetching bookmarks for thread:", threadId);
-    return getBookmarksByThread(this, threadId, timeout);
+  async queryBookmarks(options = {}, timeout) {
+    this.log("info", "Querying bookmarks with filters:", options.filters);
+    return queryBookmarks(this, options, timeout);
   }
   // ==================== Report Management Methods ====================
   // These methods delegate to report service for admin report CRUD operations
@@ -2347,6 +2729,88 @@ var SuperatomClient = class {
     this.log("info", "Querying UIs with filters:", options?.filters);
     return queryUIs(this, options, timeout);
   }
+  // ==================== KB Nodes (Knowledge Base) Management Methods ====================
+  // These methods delegate to kb-nodes service for knowledge base CRUD operations
+  /**
+   * Create a new knowledge base node
+   * Delegates to kb-nodes service
+   */
+  async createKbNode(title, content, createdBy, category, tags, timeout) {
+    this.log("info", "Creating KB node:", title);
+    return createKbNode(this, title, content, createdBy, category, tags, timeout);
+  }
+  /**
+   * Update an existing knowledge base node
+   * Delegates to kb-nodes service
+   */
+  async updateKbNode(id, updatedBy, updates, timeout) {
+    this.log("info", "Updating KB node:", id);
+    return updateKbNode(this, id, updatedBy, updates, timeout);
+  }
+  /**
+   * Delete a knowledge base node
+   * Delegates to kb-nodes service
+   */
+  async deleteKbNode(id, timeout) {
+    this.log("info", "Deleting KB node:", id);
+    return deleteKbNode(this, id, timeout);
+  }
+  /**
+   * Get all knowledge base nodes
+   * Delegates to kb-nodes service
+   */
+  async getAllKbNodes(limit, offset, timeout) {
+    this.log("info", "Fetching all KB nodes");
+    return getAllKbNodes(this, limit, offset, timeout);
+  }
+  /**
+   * Get a specific knowledge base node by ID
+   * Delegates to kb-nodes service
+   */
+  async getKbNode(id, timeout) {
+    this.log("info", "Fetching KB node:", id);
+    return getKbNode(this, id, timeout);
+  }
+  /**
+   * Search knowledge base nodes with full-text search and filters
+   * Delegates to kb-nodes service
+   */
+  async searchKbNodes(options = {}, timeout) {
+    this.log("info", "Searching KB nodes with query:", options.query);
+    return searchKbNodes(this, options, timeout);
+  }
+  /**
+   * Get knowledge base nodes by category
+   * Delegates to kb-nodes service
+   */
+  async getKbNodesByCategory(category, limit, offset, timeout) {
+    this.log("info", "Fetching KB nodes by category:", category);
+    return getKbNodesByCategory(this, category, limit, offset, timeout);
+  }
+  /**
+   * Get knowledge base nodes by user (creator)
+   * Delegates to kb-nodes service
+   */
+  async getKbNodesByUser(userId, limit, offset, timeout) {
+    this.log("info", "Fetching KB nodes by user:", userId);
+    return getKbNodesByUser(this, userId, limit, offset, timeout);
+  }
+  /**
+   * Get all unique categories from knowledge base nodes
+   * Delegates to kb-nodes service
+   */
+  async getKbNodeCategories(timeout) {
+    this.log("info", "Fetching KB node categories");
+    return getKbNodeCategories(this, timeout);
+  }
+  /**
+   * Get all unique tags from knowledge base nodes
+   * Delegates to kb-nodes service
+   */
+  async getKbNodeTags(timeout) {
+    this.log("info", "Fetching KB node tags");
+    return getKbNodeTags(this, timeout);
+  }
   /**
    * Internal logging
    */
@@ -2418,6 +2882,12 @@ exports.DataRequestMessageSchema = DataRequestMessageSchema;
 exports.DataRequestPayloadSchema = DataRequestPayloadSchema;
 exports.DataResponseMessageSchema = DataResponseMessageSchema;
 exports.DataResponsePayloadSchema = DataResponsePayloadSchema;
+exports.KbNodeDataSchema = KbNodeDataSchema;
+exports.KbNodesQueryFiltersSchema = KbNodesQueryFiltersSchema;
+exports.KbNodesRequestMessageSchema = KbNodesRequestMessageSchema;
+exports.KbNodesRequestPayloadSchema = KbNodesRequestPayloadSchema;
+exports.KbNodesResponseMessageSchema = KbNodesResponseMessageSchema;
+exports.KbNodesResponsePayloadSchema = KbNodesResponsePayloadSchema;
 exports.MessageParticipantSchema = MessageParticipantSchema;
 exports.MessageSchema = MessageSchema;
 exports.SDK_VERSION = SDK_VERSION;