@app-connect/core 1.7.10 → 1.7.12

package/mcp/tools/updateCallLog.js

@@ -0,0 +1,122 @@
+const jwt = require('../../lib/jwt');
+const connectorRegistry = require('../../connector/registry');
+const logCore = require('../../handlers/log');
+const util = require('../../lib/util');
+
+/**
+ * MCP Tool: Update Call Log
+ * 
+ * This tool updates an existing call log in the CRM platform.
+ */
+
+const toolDefinition = {
+    name: 'updateCallLog',
+    description: '⚠️ REQUIRES AUTHENTICATION: User must first authenticate using the "auth" tool to obtain a JWT token before using this tool. | Update an existing call log in the CRM platform. Returns the updated log ID if successful.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            jwtToken: {
+                type: 'string',
+                description: 'JWT token containing userId and platform information. If user does not have this, direct them to use the "auth" tool first.'
+            },
+            incomingData: {
+                type: 'object',
+                description: 'Call log update data including sessionId, note, additionalSubmission, etc.',
+                properties: {
+                    sessionId: {
+                        type: 'string',
+                        description: 'Session ID of the call log to update'
+                    },
+                    note: {
+                        type: 'string',
+                        description: 'Updated call note/description'
+                    },
+                    additionalSubmission: {
+                        type: 'object',
+                        description: 'Additional platform-specific fields to update'
+                    },
+                    accountId: {
+                        type: 'string',
+                        description: 'RingCentral account ID'
+                    }
+                },
+                required: ['sessionId']
+            }
+        },
+        required: ['jwtToken', 'incomingData']
+    }
+};
+
+/**
+ * Execute the updateCallLog tool
+ * @param {Object} args - The tool arguments
+ * @param {string} args.jwtToken - JWT token with user and platform info
+ * @param {Object} args.incomingData - Call log update data
+ * @returns {Object} Result object with updated log ID
+ */
+async function execute(args) {
+    try {
+        const { jwtToken, incomingData } = args;
+        
+        // Decode JWT to get userId and platform
+        const { id: userId, platform } = jwt.decodeJwt(jwtToken);
+        
+        if (!userId) {
+            throw new Error('Invalid JWT token: userId not found');
+        }
+
+        // Get the platform connector module
+        const platformModule = connectorRegistry.getConnector(platform);
+        
+        if (!platformModule) {
+            throw new Error(`Platform connector not found for: ${platform}`);
+        }
+
+        // Check if updateCallLog is implemented
+        if (!platformModule.updateCallLog) {
+            throw new Error(`updateCallLog is not implemented for platform: ${platform}`);
+        }
+
+        // Calculate hashed account ID
+        const hashedAccountId = incomingData.accountId 
+            ? util.getHashValue(incomingData.accountId, process.env.HASH_KEY) 
+            : undefined;
+
+        // Call the updateCallLog method
+        const { successful, logId, updatedNote, returnMessage } = await logCore.updateCallLog({ 
+            platform, 
+            userId, 
+            incomingData, 
+            hashedAccountId,
+            isFromSSCL: false 
+        });
+        
+        if (successful) {
+            return {
+                success: true,
+                data: {
+                    logId,
+                    updatedNote,
+                    message: returnMessage?.message || 'Call log updated successfully'
+                }
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: returnMessage?.message || 'Failed to update call log',
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Unknown error occurred',
+            errorDetails: error.stack
+        };
+    }
+}
+
+exports.definition = toolDefinition;
+exports.execute = execute;
+

package/models/cacheModel.js

@@ -17,6 +17,9 @@ exports.CacheModel = sequelize.define('cache', {
     cacheKey: {
         type: Sequelize.STRING,
     },
+    data: {
+        type: Sequelize.JSON
+    },
     expiry: {
         type: Sequelize.DATE
     }

package/package.json

@@ -1,70 +1,71 @@
-{
-  "name": "@app-connect/core",
-  "version": "1.7.10",
-  "description": "RingCentral App Connect Core",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ringcentral/rc-unified-crm-extension.git"
-  },
-  "keywords": [
-    "RingCentral",
-    "App Connect"
-  ],
-  "author": "RingCentral Labs",
-  "license": "MIT",
-  "peerDependencies": {
-    "axios": "^1.12.2",
-    "express": "^4.22.1",
-    "moment": "^2.29.4",
-    "moment-timezone": "^0.5.39",
-    "pg": "^8.8.0",
-    "sequelize": "^6.29.0"
-  },
-  "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.751.0",
-    "@aws-sdk/client-s3": "^3.947.0",
-    "@aws-sdk/s3-request-presigner": "^3.947.0",
-    "body-parser": "^1.20.4",
-    "body-parser-xml": "^2.0.5",
-    "client-oauth2": "^4.3.3",
-    "cors": "^2.8.5",
-    "country-state-city": "^3.2.1",
-    "dotenv": "^16.0.3",
-    "dynamoose": "^4.0.3",
-    "jsonwebtoken": "^9.0.0",
-    "mixpanel": "^0.18.0",
-    "shortid": "^2.2.17",
-    "tz-lookup": "^6.1.25",
-    "ua-parser-js": "^1.0.38"
-  },
-  "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:ci": "jest --ci --coverage --watchAll=false"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.22.0",
-    "@octokit/rest": "^19.0.5",
-    "axios": "^1.12.2",
-    "eslint": "^9.22.0",
-    "express": "^4.22.1",
-    "globals": "^16.0.0",
-    "jest": "^29.3.1",
-    "moment": "^2.29.4",
-    "moment-timezone": "^0.5.39",
-    "nock": "^13.2.9",
-    "pg": "^8.8.0",
-    "sequelize": "^6.29.0",
-    "sqlite3": "^5.1.2",
-    "supertest": "^6.3.1"
-  },
-  "overrides": {
-    "js-object-utilities": "2.2.1"
-  },
-  "bugs": {
-    "url": "https://github.com/ringcentral/rc-unified-crm-extension/issues"
-  },
-  "homepage": "https://github.com/ringcentral/rc-unified-crm-extension#readme"
-}
+{
+  "name": "@app-connect/core",
+  "version": "1.7.12",
+  "description": "RingCentral App Connect Core",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ringcentral/rc-unified-crm-extension.git"
+  },
+  "keywords": [
+    "RingCentral",
+    "App Connect"
+  ],
+  "author": "RingCentral Labs",
+  "license": "MIT",
+  "peerDependencies": {
+    "axios": "^1.12.2",
+    "express": "^4.22.1",
+    "moment": "^2.29.4",
+    "moment-timezone": "^0.5.39",
+    "pg": "^8.8.0",
+    "sequelize": "^6.29.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.751.0",
+    "@modelcontextprotocol/sdk": "^1.21.1",
+    "@aws-sdk/client-s3": "^3.947.0",
+    "@aws-sdk/s3-request-presigner": "^3.947.0",
+    "body-parser": "^1.20.4",
+    "body-parser-xml": "^2.0.5",
+    "client-oauth2": "^4.3.3",
+    "cors": "^2.8.5",
+    "country-state-city": "^3.2.1",
+    "dotenv": "^16.0.3",
+    "dynamoose": "^4.0.3",
+    "jsonwebtoken": "^9.0.0",
+    "mixpanel": "^0.18.0",
+    "shortid": "^2.2.17",
+    "tz-lookup": "^6.1.25",
+    "ua-parser-js": "^1.0.38"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.22.0",
+    "@octokit/rest": "^19.0.5",
+    "axios": "^1.12.2",
+    "eslint": "^9.22.0",
+    "express": "^4.22.1",
+    "globals": "^16.0.0",
+    "jest": "^29.3.1",
+    "moment": "^2.29.4",
+    "moment-timezone": "^0.5.39",
+    "nock": "^13.2.9",
+    "pg": "^8.8.0",
+    "sequelize": "^6.29.0",
+    "sqlite3": "^5.1.2",
+    "supertest": "^6.3.1"
+  },
+  "overrides": {
+    "js-object-utilities": "2.2.1"
+  },
+  "bugs": {
+    "url": "https://github.com/ringcentral/rc-unified-crm-extension/issues"
+  },
+  "homepage": "https://github.com/ringcentral/rc-unified-crm-extension#readme"
+}

package/releaseNotes.json

@@ -1,4 +1,28 @@
 {
+    "1.7.12": {
+        "global": [
+            {
+                "type": "New",
+                "description": "A button on Developer settings page to re-initialize user mapping"
+            },
+            {
+                "type": "Better",
+                "description": "Click-to-SMS button is disabled if RingCentral SMS service is not activated"
+            }
+        ]
+    },
+    "1.7.11": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Shared-SMS logging"
+            },
+            {
+                "type": "New",
+                "description": "MCP tools"
+            }
+        ]
+    },
     "1.7.10": {
         "global": [
             {

package/test/handlers/log.test.js

@@ -691,10 +691,12 @@ describe('Log Handler', () => {
         platformAdditionalInfo: {}
       });
 
+      // Create existing message log with same conversationLogId
       await MessageLogModel.create({
         id: 'msg-1',
         platform: 'testCRM',
         conversationId: 'conv-123',
+        conversationLogId: 'conv-log-123',
         thirdPartyLogId: 'existing-log',
         userId: 'test-user-id'
       });
@@ -705,6 +707,9 @@ describe('Log Handler', () => {
         createMessageLog: jest.fn().mockResolvedValue({
           logId: 'msg-log-new',
           returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
+        }),
+        updateMessageLog: jest.fn().mockResolvedValue({
+          returnMessage: { message: 'Message updated', messageType: 'success', ttl: 2000 }
         })
       };
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
@@ -717,7 +722,7 @@ describe('Log Handler', () => {
           ],
           correspondents: [{ phoneNumber: '+1234567890' }],
           conversationId: 'conv-123',
-          conversationLogId: 'new-conv-log-123'
+          conversationLogId: 'conv-log-123'  // Same conversationLogId as existing record
         },
         contactId: 'contact-123',
         contactType: 'Contact',
@@ -733,8 +738,9 @@ describe('Log Handler', () => {
 
       // Assert
       expect(result.successful).toBe(true);
-      // Only the new message should be logged
-      expect(mockConnector.createMessageLog).toHaveBeenCalledTimes(1);
+      // msg-1 is skipped (already logged), msg-2 uses updateMessageLog because same conversationLogId exists
+      expect(mockConnector.createMessageLog).toHaveBeenCalledTimes(0);
+      expect(mockConnector.updateMessageLog).toHaveBeenCalledTimes(1);
     });
   });
 
@@ -767,7 +773,8 @@ describe('Log Handler', () => {
 
       // Assert
       expect(result.successful).toBe(false);
-      expect(result.returnMessage).toBe('Error saving note cache');
+      expect(result.returnMessage.message).toBe('Error performing saveNoteCache');
+      expect(result.returnMessage.messageType).toBe('warning');
     });
   });
 

package/test/lib/logger.test.js

@@ -0,0 +1,206 @@
+const { Logger, LOG_LEVELS } = require('../../lib/logger');
+
+describe('Logger', () => {
+  let originalEnv;
+  let consoleSpy;
+  let consoleErrorSpy;
+
+  beforeEach(() => {
+    originalEnv = process.env.NODE_ENV;
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+  });
+
+  afterEach(() => {
+    process.env.NODE_ENV = originalEnv;
+    consoleSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('Log Levels', () => {
+    test('should only log messages at or above the configured level', () => {
+      const logger = new Logger({ level: 'WARN' });
+
+      logger.debug('debug message');
+      logger.info('info message');
+      logger.warn('warn message');
+      logger.error('error message');
+
+      // Only warn and error should be logged
+      expect(consoleSpy).not.toHaveBeenCalled();
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
+    });
+
+    test('should log all messages when level is DEBUG', () => {
+      const logger = new Logger({ level: 'DEBUG' });
+
+      logger.debug('debug message');
+      logger.info('info message');
+      logger.warn('warn message');
+      logger.error('error message');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(2); // debug and info
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(2); // warn and error
+    });
+  });
+
+  describe('Production vs Development', () => {
+    test('should output JSON in production', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = new Logger({ level: 'INFO' });
+
+      logger.info('test message', { userId: '123' });
+
+      const logOutput = consoleSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logOutput);
+
+      expect(parsed).toHaveProperty('timestamp');
+      expect(parsed).toHaveProperty('level', 'INFO');
+      expect(parsed).toHaveProperty('message', 'test message');
+      expect(parsed).toHaveProperty('userId', '123');
+    });
+
+    test('should output human-readable format in development', () => {
+      process.env.NODE_ENV = 'development';
+      const logger = new Logger({ level: 'INFO' });
+
+      logger.info('test message', { userId: '123' });
+
+      const logOutput = consoleSpy.mock.calls[0][0];
+      expect(logOutput).toContain('[INFO]');
+      expect(logOutput).toContain('test message');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should extract error information from Error objects', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = new Logger({ level: 'ERROR' });
+      const error = new Error('Test error');
+      error.response = {
+        status: 500,
+        data: { message: 'Server error' },
+      };
+
+      logger.error('Operation failed', { error });
+
+      const logOutput = consoleErrorSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logOutput);
+
+      expect(parsed).toHaveProperty('errorMessage', 'Test error');
+      expect(parsed).toHaveProperty('errorStack');
+      expect(parsed).toHaveProperty('errorStatus', 500);
+      expect(parsed).toHaveProperty('errorResponse');
+      expect(parsed).not.toHaveProperty('error'); // Should be removed
+    });
+  });
+
+  describe('Child Logger', () => {
+    test('should create child logger with default context', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = new Logger({ level: 'INFO' });
+      const childLogger = logger.child({ platform: 'clio', userId: '123' });
+
+      childLogger.info('test message', { operation: 'createLog' });
+
+      const logOutput = consoleSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logOutput);
+
+      expect(parsed).toHaveProperty('platform', 'clio');
+      expect(parsed).toHaveProperty('userId', '123');
+      expect(parsed).toHaveProperty('operation', 'createLog');
+    });
+
+    test('should support nested child loggers', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = new Logger({ level: 'INFO' });
+      const child1 = logger.child({ platform: 'clio' });
+      const child2 = child1.child({ userId: '123' });
+
+      child2.info('test message');
+
+      const logOutput = consoleSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logOutput);
+
+      expect(parsed).toHaveProperty('platform', 'clio');
+      expect(parsed).toHaveProperty('userId', '123');
+    });
+  });
+
+  describe('API Request Logging', () => {
+    test('should log successful API requests at DEBUG level', () => {
+      const logger = new Logger({ level: 'DEBUG' });
+
+      logger.logApiRequest({
+        method: 'GET',
+        url: 'https://api.example.com/users',
+        status: 200,
+        duration: 150,
+        platform: 'clio',
+      });
+
+      expect(consoleSpy).toHaveBeenCalledTimes(1);
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+    });
+
+    test('should log failed API requests at ERROR level', () => {
+      const logger = new Logger({ level: 'ERROR' });
+      const error = new Error('Request failed');
+
+      logger.logApiRequest({
+        method: 'POST',
+        url: 'https://api.example.com/logs',
+        status: 500,
+        duration: 300,
+        platform: 'clio',
+        error,
+      });
+
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+
+    test('should log 4xx errors at WARN level', () => {
+      const logger = new Logger({ level: 'WARN' });
+
+      logger.logApiRequest({
+        method: 'GET',
+        url: 'https://api.example.com/contact/999',
+        status: 404,
+        duration: 100,
+        platform: 'clio',
+      });
+
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Database Query Logging', () => {
+    test('should log successful queries at DEBUG level', () => {
+      const logger = new Logger({ level: 'DEBUG' });
+
+      logger.logDatabaseQuery({
+        operation: 'SELECT',
+        table: 'users',
+        duration: 50,
+      });
+
+      expect(consoleSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test('should log failed queries at ERROR level', () => {
+      const logger = new Logger({ level: 'ERROR' });
+      const error = new Error('Constraint violation');
+
+      logger.logDatabaseQuery({
+        operation: 'INSERT',
+        table: 'call_logs',
+        duration: 20,
+        error,
+      });
+
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+});
+

package/test/lib/ringcentral.test.js

@@ -126,9 +126,6 @@ describe('ringcentral', () => {
         expect(result.refresh_token).toBe('new-refresh-token');
         expect(result.expire_time).toBeDefined();
         expect(result.refresh_token_expire_time).toBeDefined();
-        // These should not be included
-        expect(result.scope).toBeUndefined();
-        expect(result.endpoint_id).toBeUndefined();
       });
 
       test('should throw error on failed token generation', async () => {
@@ -317,9 +314,6 @@ describe('ringcentral', () => {
         }, token);
 
         expect(result.id).toBe('sub-123');
-        // These should not be included in result
-        expect(result.uri).toBeUndefined();
-        expect(result.creationTime).toBeUndefined();
       });
     });