@app-connect/core 1.7.19 → 1.7.21

package/models/userModel.js

@@ -36,6 +36,9 @@ exports.UserModel = sequelize.define('users', {
   platformAdditionalInfo: {
     type: Sequelize.JSON
   },
+  hashedRcExtensionId: {
+    type: Sequelize.STRING,
+  },
   userSettings: {
     type: Sequelize.JSON
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.19",
+  "version": "1.7.21",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,4 +1,28 @@
 {
+    "1.7.21": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "Refresh contact for deleted contact issue"
+            },
+            {
+                "type": "Fix",
+                "description": "Click-to-sms button issue"
+            }
+        ]
+    },
+    "1.7.20": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "Click-to-dial not detecting numbers in input fields"
+            },
+            {
+                "type": "Fix",
+                "description": "Warm transfer call logging issue"
+            }
+        ]
+    },
     "1.7.19": {
         "global": [
             {

package/test/handlers/auth.test.js

@@ -501,6 +501,7 @@ describe('Auth Handler', () => {
   describe('getLicenseStatus', () => {
     test('should return license status from platform module', async () => {
       // Arrange
+      const mockUser = global.testUtils.createMockUser({ id: 'user-123' });
       const mockLicenseStatus = {
         isValid: true,
         expiresAt: '2025-12-31',
@@ -513,6 +514,9 @@ describe('Auth Handler', () => {
 
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findByPk').mockResolvedValue(mockUser);
+
       // Act
       const result = await authHandler.getLicenseStatus({
         userId: 'user-123',
@@ -523,8 +527,35 @@ describe('Auth Handler', () => {
       expect(result).toEqual(mockLicenseStatus);
       expect(mockConnector.getLicenseStatus).toHaveBeenCalledWith({
         userId: 'user-123',
+        platform: 'testCRM',
+        user: mockUser
+      });
+    });
+
+    test('should return invalid license status when user not found', async () => {
+      // Arrange
+      const mockConnector = global.testUtils.createMockConnector({
+        getLicenseStatus: jest.fn()
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findByPk').mockResolvedValue(null);
+
+      // Act
+      const result = await authHandler.getLicenseStatus({
+        userId: 'missing-user',
         platform: 'testCRM'
       });
+
+      // Assert
+      expect(result).toEqual({
+        isLicenseValid: false,
+        licenseStatus: 'Invalid (User not found)',
+        licenseStatusDescription: ''
+      });
+      expect(connectorRegistry.getConnector).not.toHaveBeenCalled();
+      expect(mockConnector.getLicenseStatus).not.toHaveBeenCalled();
     });
   });
 

package/test/handlers/contact.test.js

@@ -436,6 +436,168 @@ describe('Contact Handler', () => {
       expect(cachedData.data).toEqual(updatedContact);
     });
 
+    test('should remove cached contact when force refresh returns null', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-123',
+        platformName: 'testCRM',
+        dataKey: 'contact-+3333333333',
+        data: [{ id: 'stale-contact', name: 'Stale Contact' }]
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        findContact: jest.fn().mockResolvedValue({
+          successful: false,
+          matchedContactInfo: null
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await contactHandler.findContact({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        phoneNumber: '+3333333333',
+        isForceRefreshAccountData: true
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      const cachedData = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-123',
+          platformName: 'testCRM',
+          dataKey: 'contact-+3333333333'
+        }
+      });
+      expect(cachedData).toBeNull();
+    });
+
+    test('should remove cached contact when force refresh returns empty array', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-123',
+        platformName: 'testCRM',
+        dataKey: 'contact-+1212121212',
+        data: [{ id: 'stale-contact', name: 'Stale Contact' }]
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        findContact: jest.fn().mockResolvedValue({
+          successful: false,
+          matchedContactInfo: []
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      await contactHandler.findContact({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        phoneNumber: '+1212121212',
+        isForceRefreshAccountData: true
+      });
+
+      // Assert
+      const cachedData = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-123',
+          platformName: 'testCRM',
+          dataKey: 'contact-+1212121212'
+        }
+      });
+      expect(cachedData).toBeNull();
+    });
+
+    test('should remove cached contact when force refresh returns only new contact placeholder', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-123',
+        platformName: 'testCRM',
+        dataKey: 'contact-+3434343434',
+        data: [{ id: 'stale-contact', name: 'Stale Contact' }]
+      });
+
+      const placeholderContact = [
+        { id: 'new-contact', name: 'Create Contact', isNewContact: true }
+      ];
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        findContact: jest.fn().mockResolvedValue({
+          successful: false,
+          matchedContactInfo: placeholderContact
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await contactHandler.findContact({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        phoneNumber: '+3434343434',
+        isForceRefreshAccountData: true
+      });
+
+      // Assert
+      expect(result.contact).toEqual(placeholderContact);
+      const cachedData = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-123',
+          platformName: 'testCRM',
+          dataKey: 'contact-+3434343434'
+        }
+      });
+      expect(cachedData).toBeNull();
+    });
+
+    test('should keep cached contact when force refresh connector call errors', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-123',
+        platformName: 'testCRM',
+        dataKey: 'contact-+5656565656',
+        data: [{ id: 'stale-contact', name: 'Stale Contact' }]
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        findContact: jest.fn().mockRejectedValue({
+          response: { status: 500 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await contactHandler.findContact({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        phoneNumber: '+5656565656',
+        isForceRefreshAccountData: true
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      const cachedData = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-123',
+          platformName: 'testCRM',
+          dataKey: 'contact-+5656565656'
+        }
+      });
+      expect(cachedData).not.toBeNull();
+      expect(cachedData.data).toEqual([{ id: 'stale-contact', name: 'Stale Contact' }]);
+    });
+
     test('should work with tracer when provided', async () => {
       // Arrange
       await UserModel.create(mockUser);

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

@@ -94,8 +94,9 @@ describe('MCP Tool: logout', () => {
       });
     });
 
-    test('should handle logout errors gracefully', async () => {
+    test('should treat CRM unAuthorize failure as non-fatal and still succeed', async () => {
       // Arrange
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
       const mockUser = {
         id: 'test-user-id',
         platform: 'testCRM'
@@ -120,10 +121,12 @@ describe('MCP Tool: logout', () => {
         jwtToken: 'mock-jwt-token'
       });
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Logout API failed');
-      expect(result.errorDetails).toBeDefined();
+      // Assert — local session is cleared; CRM revoke errors are logged only
+      expect(result.success).toBe(true);
+      expect(result.data.message).toContain('IMPORTANT');
+      expect(mockConnector.unAuthorize).toHaveBeenCalled();
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
     });
 
     test('should handle invalid JWT token', async () => {
@@ -140,8 +143,9 @@ describe('MCP Tool: logout', () => {
       expect(result.error).toBeDefined();
     });
 
-    test('should handle missing platform connector', async () => {
+    test('should succeed when platform connector is missing (unAuthorize skipped)', async () => {
       // Arrange
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
       const mockUser = {
         id: 'test-user-id',
         platform: 'unknownCRM'
@@ -160,9 +164,11 @@ describe('MCP Tool: logout', () => {
         jwtToken: 'mock-jwt-token'
       });
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
+      // Assert — null connector throws on unAuthorize; error is caught, logout still succeeds locally
+      expect(result.success).toBe(true);
+      expect(result.data.message).toContain('IMPORTANT');
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
     });
   });
 });