@app-connect/core 1.7.36 → 1.7.38

package/test/mcp/tools/getCallLog.test.js

@@ -1,298 +0,0 @@
-const getCallLog = require('../../../mcp/tools/getCallLog');
-const jwt = require('../../../lib/jwt');
-const connectorRegistry = require('../../../connector/registry');
-const logCore = require('../../../handlers/log');
-
-// Mock dependencies
-jest.mock('../../../lib/jwt');
-jest.mock('../../../connector/registry');
-jest.mock('../../../handlers/log');
-
-describe('MCP Tool: getCallLog', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(getCallLog.definition).toBeDefined();
-      expect(getCallLog.definition.name).toBe('getCallLog');
-      expect(getCallLog.definition.description).toContain('REQUIRES AUTHENTICATION');
-      expect(getCallLog.definition.inputSchema).toBeDefined();
-    });
-
-    test('should require jwtToken and sessionIds parameters', () => {
-      expect(getCallLog.definition.inputSchema.required).toContain('jwtToken');
-      expect(getCallLog.definition.inputSchema.required).toContain('sessionIds');
-    });
-
-    test('should have requireDetails optional parameter', () => {
-      expect(getCallLog.definition.inputSchema.properties).toHaveProperty('requireDetails');
-    });
-  });
-
-  describe('execute', () => {
-    test('should get call log successfully', async () => {
-      // Arrange
-      const mockLogs = [
-        {
-          id: 'log-123',
-          sessionId: 'session-123',
-          contactId: 'contact-123',
-          phoneNumber: '+1234567890',
-          callDirection: 'Inbound',
-          callDuration: 120
-        }
-      ];
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'testCRM'
-      });
-
-      const mockConnector = {
-        getCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      logCore.getCallLog.mockResolvedValue({
-        successful: true,
-        logs: mockLogs,
-        returnMessage: { message: 'Logs retrieved' }
-      });
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'session-123'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: mockLogs
-      });
-      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
-      expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
-      expect(logCore.getCallLog).toHaveBeenCalledWith({
-        userId: 'user-123',
-        sessionIds: 'session-123',
-        platform: 'testCRM',
-        requireDetails: false
-      });
-    });
-
-    test('should get call logs with multiple session IDs', async () => {
-      // Arrange
-      const mockLogs = [
-        { sessionId: 'session-123', contactId: 'contact-123' },
-        { sessionId: 'session-456', contactId: 'contact-456' }
-      ];
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'testCRM'
-      });
-
-      const mockConnector = {
-        getCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      logCore.getCallLog.mockResolvedValue({
-        successful: true,
-        logs: mockLogs
-      });
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'session-123,session-456'
-      });
-
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveLength(2);
-      expect(logCore.getCallLog).toHaveBeenCalledWith({
-        userId: 'user-123',
-        sessionIds: 'session-123,session-456',
-        platform: 'testCRM',
-        requireDetails: false
-      });
-    });
-
-    test('should get call logs with detailed information', async () => {
-      // Arrange
-      const mockLogs = [
-        {
-          sessionId: 'session-123',
-          contactId: 'contact-123',
-          detailedInfo: { recording: 'url', transcript: 'text' }
-        }
-      ];
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'testCRM'
-      });
-
-      const mockConnector = {
-        getCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      logCore.getCallLog.mockResolvedValue({
-        successful: true,
-        logs: mockLogs
-      });
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'session-123',
-        requireDetails: true
-      });
-
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual(mockLogs);
-      expect(logCore.getCallLog).toHaveBeenCalledWith({
-        userId: 'user-123',
-        sessionIds: 'session-123',
-        platform: 'testCRM',
-        requireDetails: true
-      });
-    });
-
-    test('should return error when logs not found', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'testCRM'
-      });
-
-      const mockConnector = {
-        getCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      logCore.getCallLog.mockResolvedValue({
-        successful: false,
-        logs: [],
-        returnMessage: { message: 'Logs not found' }
-      });
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'non-existent-session'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'Logs not found'
-      });
-    });
-
-    test('should return error when JWT is invalid', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        platform: 'testCRM'
-        // id is missing
-      });
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'invalid-token',
-        sessionIds: 'session-123'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Invalid JWT token');
-    });
-
-    test('should return error when decodeJwt returns null', async () => {
-      jwt.decodeJwt.mockReturnValue(null);
-
-      const result = await getCallLog.execute({
-        jwtToken: 'invalid-token',
-        sessionIds: ['session-123']
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Invalid JWT token');
-    });
-
-    test('should return error when platform connector not found', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'unknownCRM'
-      });
-
-      connectorRegistry.getConnector.mockReturnValue(null);
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'session-123'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Platform connector not found');
-    });
-
-    test('should return error when getCallLog is not implemented', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'testCRM'
-      });
-
-      const mockConnector = {}; // No getCallLog method
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'session-123'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('not implemented');
-    });
-
-    test('should handle unexpected errors gracefully', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123',
-        platform: 'testCRM'
-      });
-
-      const mockConnector = {
-        getCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      logCore.getCallLog.mockRejectedValue(
-        new Error('Database query failed')
-      );
-
-      // Act
-      const result = await getCallLog.execute({
-        jwtToken: 'mock-jwt-token',
-        sessionIds: 'session-123'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Database query failed');
-      expect(result.errorDetails).toBeDefined();
-    });
-  });
-});
-

package/test/mcp/tools/getGoogleFilePicker.test.js

@@ -1,281 +0,0 @@
-const getGoogleFilePicker = require('../../../mcp/tools/getGoogleFilePicker');
-const jwt = require('../../../lib/jwt');
-const { UserModel } = require('../../../models/userModel');
-const axios = require('axios');
-
-// Mock dependencies
-jest.mock('../../../lib/jwt');
-jest.mock('../../../models/userModel');
-jest.mock('axios');
-
-describe('MCP Tool: getGoogleFilePicker', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    process.env.APP_SERVER = 'https://test-app-server.com';
-  });
-
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(getGoogleFilePicker.definition).toBeDefined();
-      expect(getGoogleFilePicker.definition.name).toBe('getGoogleFilePicker');
-      expect(getGoogleFilePicker.definition.description).toContain('REQUIRES CRM CONNECTION');
-      expect(getGoogleFilePicker.definition.description).toContain('Google Sheets file picker');
-      expect(getGoogleFilePicker.definition.inputSchema).toBeDefined();
-    });
-
-    test('should not require jwtToken in schema (it is server-injected)', () => {
-      expect(getGoogleFilePicker.definition.inputSchema.required).not.toContain('jwtToken');
-    });
-
-    test('should have optional sheetName parameter', () => {
-      expect(getGoogleFilePicker.definition.inputSchema.properties).toHaveProperty('sheetName');
-      expect(getGoogleFilePicker.definition.inputSchema.required).not.toContain('sheetName');
-    });
-
-    test('should have correct annotations', () => {
-      expect(getGoogleFilePicker.definition.annotations).toEqual({
-        readOnlyHint: false,
-        openWorldHint: true,
-        destructiveHint: false
-      });
-    });
-  });
-
-  describe('execute - file picker URL', () => {
-    test('should return file picker URL successfully', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123'
-      });
-
-      UserModel.findByPk.mockResolvedValue({
-        id: 'user-123',
-        name: 'Test User'
-      });
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: {
-          filePickerUrl: 'https://test-app-server.com/googleSheets/filePicker?token=mock-jwt-token',
-          message: expect.stringContaining('Please open this URL')
-        }
-      });
-      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
-      expect(UserModel.findByPk).toHaveBeenCalledWith('user-123');
-    });
-  });
-
-  describe('execute - create new sheet', () => {
-    test('should create new sheet when sheetName is provided', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123'
-      });
-
-      UserModel.findByPk.mockResolvedValue({
-        id: 'user-123',
-        name: 'Test User'
-      });
-
-      const mockSheetResponse = {
-        data: {
-          success: true,
-          data: {
-            sheetId: 'sheet-123',
-            sheetName: 'My Call Logs'
-          }
-        }
-      };
-
-      axios.post.mockResolvedValue(mockSheetResponse);
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'mock-jwt-token',
-        sheetName: 'My Call Logs'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: {
-          sheetId: 'sheet-123',
-          sheetName: 'My Call Logs'
-        }
-      });
-      expect(axios.post).toHaveBeenCalledWith(
-        'https://test-app-server.com/googleSheets/sheet?jwtToken=mock-jwt-token',
-        { name: 'My Call Logs' }
-      );
-    });
-
-    test('should return error when sheet creation fails', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123'
-      });
-
-      UserModel.findByPk.mockResolvedValue({
-        id: 'user-123',
-        name: 'Test User'
-      });
-
-      axios.post.mockRejectedValue(new Error('Failed to create sheet'));
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'mock-jwt-token',
-        sheetName: 'My Call Logs'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Failed to create sheet');
-      expect(result.errorDetails).toBeDefined();
-    });
-  });
-
-  describe('execute - error handling', () => {
-    test('should return error when jwtToken is missing', async () => {
-      // Act
-      const result = await getGoogleFilePicker.execute({});
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'JWT token is required. Please connect to the CRM first using getPublicConnectors.'
-      });
-    });
-
-    test('should return error when jwtToken is null', async () => {
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: null
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'JWT token is required. Please connect to the CRM first using getPublicConnectors.'
-      });
-    });
-
-    test('should return error when JWT is invalid (no userId)', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        // id is missing
-        platform: 'googleSheets'
-      });
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'invalid-jwt-token'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'Invalid JWT token: userId not found'
-      });
-    });
-
-    test('should return error when JWT decode returns null', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue(null);
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'malformed-jwt-token'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'Invalid JWT token: userId not found'
-      });
-    });
-
-    test('should return error when user not found', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'nonexistent-user'
-      });
-
-      UserModel.findByPk.mockResolvedValue(null);
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'User not found. Please connect to the CRM first using getPublicConnectors.'
-      });
-      expect(UserModel.findByPk).toHaveBeenCalledWith('nonexistent-user');
-    });
-
-    test('should handle database errors gracefully', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123'
-      });
-
-      UserModel.findByPk.mockRejectedValue(new Error('Database connection failed'));
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Database connection failed');
-      expect(result.errorDetails).toBeDefined();
-    });
-
-    test('should handle JWT decode errors gracefully', async () => {
-      // Arrange
-      jwt.decodeJwt.mockImplementation(() => {
-        throw new Error('JWT decode error');
-      });
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'corrupted-jwt-token'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('JWT decode error');
-      expect(result.errorDetails).toBeDefined();
-    });
-
-    test('should handle errors without message property', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'user-123'
-      });
-
-      const errorWithoutMessage = { code: 'UNKNOWN_ERROR' };
-      UserModel.findByPk.mockRejectedValue(errorWithoutMessage);
-
-      // Act
-      const result = await getGoogleFilePicker.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Unknown error occurred');
-    });
-  });
-});
-

package/test/mcp/tools/getPublicConnectors.test.js

@@ -1,107 +0,0 @@
-const getPublicConnectors = require('../../../mcp/tools/getPublicConnectors');
-const axios = require('axios');
-
-jest.mock('axios');
-
-describe('MCP Tool: getPublicConnectors', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    process.env.APP_SERVER = 'https://test-server.com';
-  });
-
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(getPublicConnectors.definition).toBeDefined();
-      expect(getPublicConnectors.definition.name).toBe('getPublicConnectors');
-      expect(getPublicConnectors.definition.description).toContain('connectors');
-      expect(getPublicConnectors.definition.inputSchema).toBeDefined();
-      expect(getPublicConnectors.definition.inputSchema.type).toBe('object');
-    });
-
-    test('should have no required parameters', () => {
-      expect(getPublicConnectors.definition.inputSchema.required).toEqual([]);
-    });
-  });
-
-  describe('execute', () => {
-    test('should return structuredContent with server URL when no rcAccessToken', async () => {
-      // Act
-      const result = await getPublicConnectors.execute({});
-
-      // Assert
-      expect(result).toEqual({
-        structuredContent: {
-          serverUrl: 'https://test-server.com',
-          rcExtensionId: null,
-          rcAccountId: null,
-          openaiSessionId: null,
-        }
-      });
-      expect(axios.get).not.toHaveBeenCalled();
-    });
-
-    test('should resolve RC account and extension IDs when rcAccessToken provided', async () => {
-      // Arrange
-      axios.get.mockResolvedValue({
-        data: { id: 'ext-456', account: { id: 'acc-789' } }
-      });
-
-      // Act
-      const result = await getPublicConnectors.execute({
-        rcAccessToken: 'valid-rc-token',
-        openaiSessionId: 'session-abc'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        structuredContent: {
-          serverUrl: 'https://test-server.com',
-          rcExtensionId: 'ext-456',
-          rcAccountId: 'acc-789',
-          openaiSessionId: 'session-abc',
-        }
-      });
-      expect(axios.get).toHaveBeenCalledWith(
-        'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
-        { headers: { Authorization: 'Bearer valid-rc-token' } }
-      );
-    });
-
-    test('should return null RC IDs and continue when RC API call fails', async () => {
-      // Arrange — RC API failure is non-fatal: widget only shows public connectors
-      axios.get.mockRejectedValue(new Error('RC API unavailable'));
-
-      // Act
-      const result = await getPublicConnectors.execute({ rcAccessToken: 'bad-token' });
-
-      // Assert — still returns structuredContent, just without RC IDs
-      expect(result).toEqual({
-        structuredContent: {
-          serverUrl: 'https://test-server.com',
-          rcExtensionId: null,
-          rcAccountId: null,
-          openaiSessionId: null,
-        }
-      });
-    });
-
-    test('should include openaiSessionId when provided', async () => {
-      // Act
-      const result = await getPublicConnectors.execute({ openaiSessionId: 'my-session' });
-
-      // Assert
-      expect(result.structuredContent.openaiSessionId).toBe('my-session');
-    });
-
-    test('should use default server URL when APP_SERVER is not set', async () => {
-      // Arrange
-      delete process.env.APP_SERVER;
-
-      // Act
-      const result = await getPublicConnectors.execute({});
-
-      // Assert
-      expect(result.structuredContent.serverUrl).toBe('https://localhost:6066');
-    });
-  });
-});