cd-aichat 1.0.0

package/src/services/dify-api.test.js

@@ -0,0 +1,376 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import DifyApiService from './dify-api.js';
+import axios from 'axios';
+
+// Mock axios
+vi.mock('axios');
+
+describe('DifyApiService', () => {
+  let mockAxiosInstance;
+  
+  beforeEach(() => {
+    // 重置所有 mocks
+    vi.clearAllMocks();
+    
+    // 创建 mock axios 实例
+    mockAxiosInstance = {
+      post: vi.fn(),
+      get: vi.fn()
+    };
+    
+    axios.create.mockReturnValue(mockAxiosInstance);
+  });
+  
+  describe('构造函数', () => {
+    it('应该支持旧的构造函数签名 (baseURL, agentId)', () => {
+      const service = new DifyApiService('https://api.dify.ai/v1', 'agent-001');
+      
+      expect(service.baseURL).toBe('https://api.dify.ai/v1');
+      expect(service.agentId).toBe('agent-001');
+      expect(service.platform).toBe('');
+      expect(service.scene).toBe('');
+    });
+    
+    it('应该支持新的配置对象签名', () => {
+      const config = {
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001',
+        platform: 'report',
+        scene: 'data-analysis',
+        knowledgeBase: {
+          type: 'json',
+          data: { test: 'data' }
+        },
+        inputVariables: {
+          userRole: 'analyst'
+        }
+      };
+      
+      const service = new DifyApiService(config);
+      
+      expect(service.baseURL).toBe('https://api.dify.ai/v1');
+      expect(service.agentId).toBe('agent-001');
+      expect(service.platform).toBe('report');
+      expect(service.scene).toBe('data-analysis');
+      expect(service.knowledgeBase).toEqual(config.knowledgeBase);
+      expect(service.inputVariables).toEqual(config.inputVariables);
+    });
+    
+    it('应该在缺少 URL 时抛出错误', () => {
+      expect(() => {
+        new DifyApiService({ agentId: 'agent-001' });
+      }).toThrow('API URL is required');
+    });
+    
+    it('应该在缺少 agentId 时抛出错误', () => {
+      expect(() => {
+        new DifyApiService({ url: 'https://api.dify.ai/v1' });
+      }).toThrow('Agent ID is required');
+    });
+    
+    it('应该设置默认的会话配置', () => {
+      const service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001'
+      });
+      
+      expect(service.conversationConfig).toEqual({
+        id: '',
+        autoCreate: true,
+        timeout: 1800000
+      });
+    });
+    
+    it('应该设置默认的响应配置', () => {
+      const service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001'
+      });
+      
+      expect(service.responseConfig).toEqual({
+        mode: 'blocking',
+        timeout: 30000,
+        maxRetries: 3
+      });
+    });
+  });
+  
+  describe('updateConfig', () => {
+    let service;
+    
+    beforeEach(() => {
+      service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001'
+      });
+    });
+    
+    it('应该更新 URL', () => {
+      service.updateConfig({ url: 'https://new-api.dify.ai/v1' });
+      expect(service.baseURL).toBe('https://new-api.dify.ai/v1');
+    });
+    
+    it('应该更新 agentId', () => {
+      service.updateConfig({ agentId: 'agent-002' });
+      expect(service.agentId).toBe('agent-002');
+    });
+    
+    it('应该更新 platform', () => {
+      service.updateConfig({ platform: 'lowcode' });
+      expect(service.platform).toBe('lowcode');
+    });
+    
+    it('应该更新 scene', () => {
+      service.updateConfig({ scene: 'form-builder' });
+      expect(service.scene).toBe('form-builder');
+    });
+    
+    it('应该更新 knowledgeBase', () => {
+      const kb = { type: 'json', data: { test: 'data' } };
+      service.updateConfig({ knowledgeBase: kb });
+      expect(service.knowledgeBase).toEqual(kb);
+    });
+    
+    it('应该更新 inputVariables', () => {
+      const vars = { userRole: 'admin' };
+      service.updateConfig({ inputVariables: vars });
+      expect(service.inputVariables).toEqual(vars);
+    });
+    
+    it('应该重新创建 axios 客户端', () => {
+      const createCallsBefore = axios.create.mock.calls.length;
+      service.updateConfig({ url: 'https://new-api.dify.ai/v1' });
+      expect(axios.create.mock.calls.length).toBe(createCallsBefore + 1);
+    });
+  });
+  
+  describe('_buildInputVariables', () => {
+    it('应该合并配置的和运行时的输入变量', () => {
+      const service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001',
+        inputVariables: {
+          configVar: 'config',
+          shared: 'fromConfig'
+        }
+      });
+      
+      const result = service._buildInputVariables({
+        runtimeVar: 'runtime',
+        shared: 'fromRuntime'
+      });
+      
+      expect(result).toEqual({
+        configVar: 'config',
+        runtimeVar: 'runtime',
+        shared: 'fromRuntime' // 运行时变量应该覆盖配置变量
+      });
+    });
+    
+    it('应该添加平台信息到输入变量', () => {
+      const service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001',
+        platform: 'report'
+      });
+      
+      const result = service._buildInputVariables();
+      
+      expect(result._platform).toBe('report');
+    });
+    
+    it('应该添加场景信息到输入变量', () => {
+      const service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001',
+        scene: 'data-analysis'
+      });
+      
+      const result = service._buildInputVariables();
+      
+      expect(result._scene).toBe('data-analysis');
+    });
+    
+    it('应该添加知识库数据到输入变量', () => {
+      const kbData = { reports: ['sales', 'finance'] };
+      const service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001',
+        knowledgeBase: {
+          type: 'json',
+          data: kbData
+        }
+      });
+      
+      const result = service._buildInputVariables();
+      
+      expect(result._knowledgeBase).toEqual(kbData);
+    });
+  });
+  
+  describe('sendMessage', () => {
+    let service;
+    
+    beforeEach(() => {
+      service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001',
+        platform: 'report',
+        scene: 'data-analysis'
+      });
+      
+      mockAxiosInstance.post.mockResolvedValue({
+        data: {
+          answer: 'AI response',
+          conversation_id: 'conv-001',
+          message_id: 'msg-001',
+          created_at: Date.now()
+        }
+      });
+    });
+    
+    it('应该发送消息到 Dify API', async () => {
+      await service.sendMessage('Hello', 'user-001');
+      
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/chat-messages',
+        expect.objectContaining({
+          query: 'Hello',
+          user: 'user-001',
+          response_mode: 'blocking'
+        }),
+        expect.objectContaining({
+          headers: {
+            'X-Agent-Id': 'agent-001'
+          }
+        })
+      );
+    });
+    
+    it('应该包含平台和场景信息在输入变量中', async () => {
+      await service.sendMessage('Hello', 'user-001');
+      
+      const callArgs = mockAxiosInstance.post.mock.calls[0][1];
+      expect(callArgs.inputs._platform).toBe('report');
+      expect(callArgs.inputs._scene).toBe('data-analysis');
+    });
+    
+    it('应该合并运行时输入变量', async () => {
+      await service.sendMessage('Hello', 'user-001', {
+        inputVariables: {
+          currentPage: 'dashboard'
+        }
+      });
+      
+      const callArgs = mockAxiosInstance.post.mock.calls[0][1];
+      expect(callArgs.inputs.currentPage).toBe('dashboard');
+    });
+    
+    it('应该使用传入的会话 ID', async () => {
+      await service.sendMessage('Hello', 'user-001', {
+        conversationId: 'conv-existing'
+      });
+      
+      const callArgs = mockAxiosInstance.post.mock.calls[0][1];
+      expect(callArgs.conversation_id).toBe('conv-existing');
+    });
+    
+    it('应该更新当前会话 ID', async () => {
+      await service.sendMessage('Hello', 'user-001');
+      
+      expect(service.currentConversationId).toBe('conv-001');
+      expect(service.conversationCreatedAt).toBeTruthy();
+    });
+    
+    it('应该在缺少 userId 时抛出错误', async () => {
+      await expect(service.sendMessage('Hello', '')).rejects.toThrow('User ID is required');
+    });
+    
+    it('应该处理 API 错误', async () => {
+      mockAxiosInstance.post.mockRejectedValue(new Error('API Error'));
+      
+      await expect(service.sendMessage('Hello', 'user-001')).rejects.toThrow('API Error');
+    });
+  });
+  
+  describe('会话管理', () => {
+    let service;
+    
+    beforeEach(() => {
+      service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001'
+      });
+    });
+    
+    it('createConversation 应该重置会话状态', async () => {
+      service.currentConversationId = 'conv-001';
+      service.conversationCreatedAt = Date.now();
+      
+      await service.createConversation('user-001');
+      
+      expect(service.currentConversationId).toBe('');
+      expect(service.conversationCreatedAt).toBeNull();
+    });
+    
+    it('getConversation 应该返回当前会话信息', async () => {
+      service.currentConversationId = 'conv-001';
+      service.conversationCreatedAt = 123456789;
+      service.platform = 'report';
+      service.scene = 'data-analysis';
+      
+      const result = await service.getConversation('conv-001');
+      
+      expect(result).toEqual({
+        id: 'conv-001',
+        createdAt: 123456789,
+        platform: 'report',
+        scene: 'data-analysis'
+      });
+    });
+    
+    it('isConversationExpired 应该检测会话超时', () => {
+      service.conversationCreatedAt = Date.now() - 2000000; // 超过 30 分钟
+      
+      expect(service.isConversationExpired()).toBe(true);
+    });
+    
+    it('isConversationExpired 应该在会话未超时时返回 false', () => {
+      service.conversationCreatedAt = Date.now() - 60000; // 1 分钟前
+      
+      expect(service.isConversationExpired()).toBe(false);
+    });
+    
+    it('resetConversation 应该重置会话状态', () => {
+      service.currentConversationId = 'conv-001';
+      service.conversationCreatedAt = Date.now();
+      
+      service.resetConversation();
+      
+      expect(service.currentConversationId).toBe('');
+      expect(service.conversationCreatedAt).toBeNull();
+    });
+  });
+  
+  describe('知识库管理', () => {
+    let service;
+    
+    beforeEach(() => {
+      service = new DifyApiService({
+        url: 'https://api.dify.ai/v1',
+        agentId: 'agent-001'
+      });
+    });
+    
+    it('updateKnowledgeBase 应该更新知识库', () => {
+      const kb = {
+        type: 'json',
+        data: { test: 'data' }
+      };
+      
+      service.updateKnowledgeBase(kb);
+      
+      expect(service.knowledgeBase).toEqual(kb);
+    });
+  });
+});

package/src/services/scheduled-send-service.js

@@ -0,0 +1,311 @@
+/**
+ * Scheduled Send Service
+ * 管理延时发送消息的调度和执行
+ */
+
+import { ref } from 'vue';
+import { saveToStorage, loadFromStorage } from '../utils/storage';
+import { validateScheduledTime } from '../utils/validation';
+
+const STORAGE_KEY = 'scheduled-messages';
+
+/**
+ * 创建延时发送服务实例
+ */
+export const createScheduledSendService = () => {
+  const scheduledMessages = ref([]);
+  const timers = ref({});
+  const listeners = ref({});
+
+  /**
+   * 初始化服务，加载已保存的消息
+   */
+  const initialize = () => {
+    const saved = loadFromStorage(STORAGE_KEY, []);
+    scheduledMessages.value = saved.map(msg => ({
+      ...msg,
+      scheduledTime: new Date(msg.scheduledTime)
+    }));
+
+    // 为每条消息设置定时器
+    scheduledMessages.value.forEach(msg => {
+      scheduleMessage(msg);
+    });
+  };
+
+  /**
+   * 添加延时消息
+   * @param {Object} message - 消息对象
+   * @param {string} message.content - 消息内容
+   * @param {Date} message.scheduledTime - 预定发送时间
+   * @returns {Object} 添加的消息对象
+   */
+  const addMessage = (message) => {
+    // 验证时间
+    const validation = validateScheduledTime(message.scheduledTime);
+    if (!validation.valid) {
+      throw new Error(validation.errors[0]);
+    }
+
+    const scheduledMessage = {
+      id: generateMessageId(),
+      content: message.content,
+      scheduledTime: message.scheduledTime,
+      createdAt: new Date(),
+      status: 'pending' // pending | sent | cancelled
+    };
+
+    scheduledMessages.value.push(scheduledMessage);
+    saveMessages();
+    scheduleMessage(scheduledMessage);
+
+    // 触发事件
+    emit('message-added', scheduledMessage);
+
+    return scheduledMessage;
+  };
+
+  /**
+   * 更新延时消息
+   * @param {string} messageId - 消息ID
+   * @param {Object} updates - 更新内容
+   * @returns {Object} 更新后的消息对象
+   */
+  const updateMessage = (messageId, updates) => {
+    const index = scheduledMessages.value.findIndex(m => m.id === messageId);
+    if (index === -1) {
+      throw new Error('消息不存在');
+    }
+
+    const message = scheduledMessages.value[index];
+
+    // 如果更新了时间，需要重新调度
+    if (updates.scheduledTime) {
+      const validation = validateScheduledTime(updates.scheduledTime);
+      if (!validation.valid) {
+        throw new Error(validation.errors[0]);
+      }
+
+      // 取消旧的定时器
+      if (timers.value[messageId]) {
+        clearTimeout(timers.value[messageId]);
+        delete timers.value[messageId];
+      }
+    }
+
+    // 更新消息
+    Object.assign(message, updates);
+    saveMessages();
+
+    // 重新调度
+    if (updates.scheduledTime) {
+      scheduleMessage(message);
+    }
+
+    // 触发事件
+    emit('message-updated', message);
+
+    return message;
+  };
+
+  /**
+   * 取消延时消息
+   * @param {string} messageId - 消息ID
+   */
+  const cancelMessage = (messageId) => {
+    const index = scheduledMessages.value.findIndex(m => m.id === messageId);
+    if (index === -1) {
+      throw new Error('消息不存在');
+    }
+
+    const message = scheduledMessages.value[index];
+
+    // 取消定时器
+    if (timers.value[messageId]) {
+      clearTimeout(timers.value[messageId]);
+      delete timers.value[messageId];
+    }
+
+    // 更新状态
+    message.status = 'cancelled';
+    saveMessages();
+
+    // 触发事件
+    emit('message-cancelled', message);
+  };
+
+  /**
+   * 获取所有待发送消息
+   * @returns {Array} 消息列表
+   */
+  const getMessages = () => {
+    return scheduledMessages.value.filter(m => m.status === 'pending');
+  };
+
+  /**
+   * 获取单个消息
+   * @param {string} messageId - 消息ID
+   * @returns {Object} 消息对象
+   */
+  const getMessage = (messageId) => {
+    return scheduledMessages.value.find(m => m.id === messageId);
+  };
+
+  /**
+   * 为消息设置定时器
+   * @private
+   */
+  const scheduleMessage = (message) => {
+    if (message.status !== 'pending') return;
+
+    const now = new Date();
+    const delay = message.scheduledTime - now;
+
+    if (delay <= 0) {
+      // 时间已过期，立即发送
+      sendMessage(message);
+      return;
+    }
+
+    // 设置定时器
+    const timerId = setTimeout(() => {
+      sendMessage(message);
+    }, delay);
+
+    timers.value[message.id] = timerId;
+  };
+
+  /**
+   * 发送消息
+   * @private
+   */
+  const sendMessage = (message) => {
+    message.status = 'sent';
+    message.sentAt = new Date();
+    saveMessages();
+
+    // 清理定时器
+    if (timers.value[message.id]) {
+      delete timers.value[message.id];
+    }
+
+    // 触发事件
+    emit('message-sent', message);
+  };
+
+  /**
+   * 保存消息到存储
+   * @private
+   */
+  const saveMessages = () => {
+    const toSave = scheduledMessages.value.map(msg => ({
+      ...msg,
+      scheduledTime: msg.scheduledTime.toISOString()
+    }));
+    saveToStorage(STORAGE_KEY, toSave);
+  };
+
+  /**
+   * 生成消息ID
+   * @private
+   */
+  const generateMessageId = () => {
+    return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  };
+
+  /**
+   * 注册事件监听器
+   * @param {string} event - 事件名称
+   * @param {Function} callback - 回调函数
+   * @returns {Function} 取消监听函数
+   */
+  const on = (event, callback) => {
+    if (!listeners.value[event]) {
+      listeners.value[event] = [];
+    }
+    listeners.value[event].push(callback);
+
+    // 返回取消监听函数
+    return () => {
+      listeners.value[event] = listeners.value[event].filter(cb => cb !== callback);
+    };
+  };
+
+  /**
+   * 触发事件
+   * @private
+   */
+  const emit = (event, data) => {
+    if (listeners.value[event]) {
+      listeners.value[event].forEach(callback => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`Error in event listener for "${event}":`, error);
+        }
+      });
+    }
+  };
+
+  /**
+   * 清理所有定时器
+   */
+  const cleanup = () => {
+    Object.values(timers.value).forEach(timerId => {
+      clearTimeout(timerId);
+    });
+    timers.value = {};
+  };
+
+  /**
+   * 获取统计信息
+   * @returns {Object} 统计信息
+   */
+  const getStats = () => {
+    return {
+      total: scheduledMessages.value.length,
+      pending: scheduledMessages.value.filter(m => m.status === 'pending').length,
+      sent: scheduledMessages.value.filter(m => m.status === 'sent').length,
+      cancelled: scheduledMessages.value.filter(m => m.status === 'cancelled').length
+    };
+  };
+
+  return {
+    scheduledMessages,
+    initialize,
+    addMessage,
+    updateMessage,
+    cancelMessage,
+    getMessages,
+    getMessage,
+    on,
+    cleanup,
+    getStats
+  };
+};
+
+/**
+ * 全局服务实例
+ */
+let globalService = null;
+
+/**
+ * 获取全局服务实例
+ */
+export const getScheduledSendService = () => {
+  if (!globalService) {
+    globalService = createScheduledSendService();
+    globalService.initialize();
+  }
+  return globalService;
+};
+
+/**
+ * 重置全局服务（用于测试）
+ */
+export const resetScheduledSendService = () => {
+  if (globalService) {
+    globalService.cleanup();
+  }
+  globalService = null;
+};