@app-connect/core 1.7.8 → 1.7.11

package/test/mcp/tools/logout.test.js

@@ -0,0 +1,169 @@
+const logout = require('../../../mcp/tools/logout');
+const jwt = require('../../../lib/jwt');
+const { UserModel } = require('../../../models/userModel');
+const connectorRegistry = require('../../../connector/registry');
+
+// Mock dependencies
+jest.mock('../../../lib/jwt');
+jest.mock('../../../models/userModel');
+jest.mock('../../../connector/registry');
+
+describe('MCP Tool: logout', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(logout.definition).toBeDefined();
+      expect(logout.definition.name).toBe('logout');
+      expect(logout.definition.description).toContain('Logout');
+      expect(logout.definition.inputSchema).toBeDefined();
+    });
+
+    test('should have jwtToken property', () => {
+      expect(logout.definition.inputSchema.properties).toHaveProperty('jwtToken');
+    });
+  });
+
+  describe('execute', () => {
+    test('should logout user successfully', async () => {
+      // Arrange
+      const mockUser = {
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-access-token'
+      };
+
+      const mockConnector = {
+        unAuthorize: jest.fn().mockResolvedValue({
+          returnMessage: {
+            messageType: 'success',
+            message: 'Logged out successfully'
+          }
+        })
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'test-user-id',
+        platform: 'testCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(mockUser);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: {
+          message: expect.stringContaining('IMPORTANT')
+        }
+      });
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
+      expect(UserModel.findByPk).toHaveBeenCalledWith('test-user-id');
+      expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
+      expect(mockConnector.unAuthorize).toHaveBeenCalledWith({
+        user: mockUser
+      });
+    });
+
+    test('should return error when user not found', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue({
+        id: 'non-existent-user',
+        platform: 'testCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(null);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: false,
+        error: 'User not found',
+        errorDetails: 'User not found'
+      });
+    });
+
+    test('should handle logout errors gracefully', async () => {
+      // Arrange
+      const mockUser = {
+        id: 'test-user-id',
+        platform: 'testCRM'
+      };
+
+      const mockConnector = {
+        unAuthorize: jest.fn().mockRejectedValue(
+          new Error('Logout API failed')
+        )
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'test-user-id',
+        platform: 'testCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(mockUser);
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Logout API failed');
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should handle invalid JWT token', async () => {
+      // Arrange
+      jwt.decodeJwt.mockReturnValue(null);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'invalid-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    test('should handle missing platform connector', async () => {
+      // Arrange
+      const mockUser = {
+        id: 'test-user-id',
+        platform: 'unknownCRM'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'test-user-id',
+        platform: 'unknownCRM'
+      });
+
+      UserModel.findByPk.mockResolvedValue(mockUser);
+      connectorRegistry.getConnector.mockReturnValue(null);
+
+      // Act
+      const result = await logout.execute({
+        jwtToken: 'mock-jwt-token'
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});
+

package/test/mcp/tools/setConnector.test.js

@@ -0,0 +1,177 @@
+const setConnector = require('../../../mcp/tools/setConnector');
+const developerPortal = require('../../../connector/developerPortal');
+
+// Mock the developerPortal module
+jest.mock('../../../connector/developerPortal');
+
+describe('MCP Tool: setConnector', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(setConnector.definition).toBeDefined();
+      expect(setConnector.definition.name).toBe('setConnector');
+      expect(setConnector.definition.description).toContain('Auth flow step.2');
+      expect(setConnector.definition.inputSchema).toBeDefined();
+    });
+
+    test('should require connectorDisplayName parameter', () => {
+      expect(setConnector.definition.inputSchema.required).toContain('connectorDisplayName');
+    });
+  });
+
+  describe('execute', () => {
+    test('should set connector successfully', async () => {
+      // Arrange
+      const mockPublicConnectors = [
+        { id: '1', name: 'salesforce', displayName: 'Salesforce', status: 'public' }
+      ];
+      const mockPrivateConnectors = [];
+      const mockManifest = {
+        platforms: {
+          salesforce: {
+            name: 'salesforce',
+            auth: { type: 'oauth' },
+            environment: { type: 'fixed' }
+          }
+        }
+      };
+
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: mockPublicConnectors
+      });
+      developerPortal.getPrivateConnectorList.mockResolvedValue({
+        privateConnectors: mockPrivateConnectors
+      });
+      developerPortal.getConnectorManifest.mockResolvedValue(mockManifest);
+
+      // Act
+      const result = await setConnector.execute({ 
+        connectorDisplayName: 'Salesforce' 
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: {
+          connectorManifest: mockManifest,
+          connectorDisplayName: 'Salesforce',
+          connectorName: 'salesforce',
+          message: expect.stringContaining('IMPORTANT')
+        }
+      });
+      expect(developerPortal.getConnectorManifest).toHaveBeenCalledWith({
+        connectorId: '1',
+        isPrivate: false
+      });
+    });
+
+    test('should handle private connector', async () => {
+      // Arrange
+      const mockPublicConnectors = [];
+      const mockPrivateConnectors = [
+        { id: '2', name: 'custom-crm', displayName: 'Custom CRM', status: 'private' }
+      ];
+      const mockManifest = {
+        platforms: {
+          'custom-crm': {
+            name: 'custom-crm',
+            auth: { type: 'apiKey' }
+          }
+        }
+      };
+
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: mockPublicConnectors
+      });
+      developerPortal.getPrivateConnectorList.mockResolvedValue({
+        privateConnectors: mockPrivateConnectors
+      });
+      developerPortal.getConnectorManifest.mockResolvedValue(mockManifest);
+
+      // Act
+      const result = await setConnector.execute({ 
+        connectorDisplayName: 'Custom CRM' 
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(result.data.connectorName).toBe('custom-crm');
+      expect(developerPortal.getConnectorManifest).toHaveBeenCalledWith({
+        connectorId: '2',
+        isPrivate: true
+      });
+    });
+
+    test('should return error when connector manifest not found', async () => {
+      // Arrange
+      const mockPublicConnectors = [
+        { id: '1', name: 'salesforce', displayName: 'Salesforce', status: 'public' }
+      ];
+      const mockPrivateConnectors = [];
+
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: mockPublicConnectors
+      });
+      developerPortal.getPrivateConnectorList.mockResolvedValue({
+        privateConnectors: mockPrivateConnectors
+      });
+      developerPortal.getConnectorManifest.mockResolvedValue(null);
+
+      // Act
+      const result = await setConnector.execute({ 
+        connectorDisplayName: 'Salesforce' 
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Connector manifest not found');
+    });
+
+    test('should return error when connector not found in list', async () => {
+      // Arrange
+      const mockPublicConnectors = [
+        { id: '1', name: 'salesforce', displayName: 'Salesforce', status: 'public' }
+      ];
+      const mockPrivateConnectors = [];
+
+      developerPortal.getPublicConnectorList.mockResolvedValue({
+        connectors: mockPublicConnectors
+      });
+      developerPortal.getPrivateConnectorList.mockResolvedValue({
+        privateConnectors: mockPrivateConnectors
+      });
+
+      // Act
+      const result = await setConnector.execute({ 
+        connectorDisplayName: 'NonExistentCRM' 
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should handle API errors gracefully', async () => {
+      // Arrange
+      const errorMessage = 'API connection failed';
+      developerPortal.getPublicConnectorList.mockRejectedValue(
+        new Error(errorMessage)
+      );
+
+      // Act
+      const result = await setConnector.execute({ 
+        connectorDisplayName: 'Salesforce' 
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe(errorMessage);
+      expect(result.errorDetails).toBeDefined();
+    });
+  });
+});
+

package/test/mcp/tools/updateCallLog.test.js

@@ -0,0 +1,346 @@
+const updateCallLog = require('../../../mcp/tools/updateCallLog');
+const jwt = require('../../../lib/jwt');
+const connectorRegistry = require('../../../connector/registry');
+const logCore = require('../../../handlers/log');
+const util = require('../../../lib/util');
+
+// Mock dependencies
+jest.mock('../../../lib/jwt');
+jest.mock('../../../connector/registry');
+jest.mock('../../../handlers/log');
+jest.mock('../../../lib/util');
+
+describe('MCP Tool: updateCallLog', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.HASH_KEY = 'test-hash-key';
+  });
+
+  describe('tool definition', () => {
+    test('should have correct tool definition', () => {
+      expect(updateCallLog.definition).toBeDefined();
+      expect(updateCallLog.definition.name).toBe('updateCallLog');
+      expect(updateCallLog.definition.description).toContain('REQUIRES AUTHENTICATION');
+      expect(updateCallLog.definition.inputSchema).toBeDefined();
+    });
+
+    test('should require jwtToken and incomingData parameters', () => {
+      expect(updateCallLog.definition.inputSchema.required).toContain('jwtToken');
+      expect(updateCallLog.definition.inputSchema.required).toContain('incomingData');
+    });
+
+    test('should require sessionId in incomingData', () => {
+      const incomingDataSchema = updateCallLog.definition.inputSchema.properties.incomingData;
+      expect(incomingDataSchema.required).toContain('sessionId');
+    });
+  });
+
+  describe('execute', () => {
+    test('should update call log successfully', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-123',
+        note: 'Updated call note',
+        accountId: 'rc-account-123'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        updateCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      util.getHashValue.mockReturnValue('hashed-account-id');
+
+      logCore.updateCallLog.mockResolvedValue({
+        successful: true,
+        logId: 'crm-log-123',
+        updatedNote: 'Updated call note',
+        returnMessage: { message: 'Call log updated successfully' }
+      });
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result).toEqual({
+        success: true,
+        data: {
+          logId: 'crm-log-123',
+          updatedNote: 'Updated call note',
+          message: 'Call log updated successfully'
+        }
+      });
+      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
+      expect(util.getHashValue).toHaveBeenCalledWith('rc-account-123', 'test-hash-key');
+      expect(logCore.updateCallLog).toHaveBeenCalledWith({
+        platform: 'testCRM',
+        userId: 'user-123',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-account-id',
+        isFromSSCL: false
+      });
+    });
+
+    test('should update call log with additional submission', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-456',
+        note: 'Updated note with additional data',
+        additionalSubmission: {
+          dealId: 'deal-123',
+          customField: 'custom-value'
+        }
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        updateCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.updateCallLog.mockResolvedValue({
+        successful: true,
+        logId: 'crm-log-456',
+        updatedNote: 'Updated note with additional data'
+      });
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(result.data.logId).toBe('crm-log-456');
+    });
+
+    test('should update call log without accountId', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-789',
+        note: 'Simple update'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        updateCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.updateCallLog.mockResolvedValue({
+        successful: true,
+        logId: 'crm-log-789',
+        updatedNote: 'Simple update'
+      });
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(util.getHashValue).not.toHaveBeenCalled();
+      expect(logCore.updateCallLog).toHaveBeenCalledWith({
+        platform: 'testCRM',
+        userId: 'user-123',
+        incomingData: mockIncomingData,
+        hashedAccountId: undefined,
+        isFromSSCL: false
+      });
+    });
+
+    test('should return error when JWT is invalid', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-123',
+        note: 'Test note'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        platform: 'testCRM'
+        // id is missing
+      });
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'invalid-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid JWT token');
+    });
+
+    test('should return error when platform connector not found', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-123',
+        note: 'Test note'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'unknownCRM'
+      });
+
+      connectorRegistry.getConnector.mockReturnValue(null);
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Platform connector not found');
+    });
+
+    test('should return error when updateCallLog is not implemented', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-123',
+        note: 'Test note'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {}; // No updateCallLog method
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not implemented');
+    });
+
+    test('should return error when update fails', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-999',
+        note: 'Test note'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        updateCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.updateCallLog.mockResolvedValue({
+        successful: false,
+        returnMessage: { message: 'Log not found in CRM' }
+      });
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Log not found in CRM');
+    });
+
+    test('should handle unexpected errors gracefully', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-error',
+        note: 'Test note'
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        updateCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.updateCallLog.mockRejectedValue(
+        new Error('API timeout')
+      );
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('API timeout');
+      expect(result.errorDetails).toBeDefined();
+    });
+
+    test('should update call log with empty note', async () => {
+      // Arrange
+      const mockIncomingData = {
+        sessionId: 'session-empty-note',
+        note: ''
+      };
+
+      jwt.decodeJwt.mockReturnValue({
+        id: 'user-123',
+        platform: 'testCRM'
+      });
+
+      const mockConnector = {
+        updateCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      logCore.updateCallLog.mockResolvedValue({
+        successful: true,
+        logId: 'crm-log-empty',
+        updatedNote: ''
+      });
+
+      // Act
+      const result = await updateCallLog.execute({
+        jwtToken: 'mock-jwt-token',
+        incomingData: mockIncomingData
+      });
+
+      // Assert
+      expect(result.success).toBe(true);
+      expect(result.data.updatedNote).toBe('');
+    });
+  });
+});
+