@app-connect/core 1.7.15 → 1.7.17

package/test/handlers/log.test.js

@@ -29,6 +29,7 @@ const logHandler = require('../../handlers/log');
 const { CallLogModel } = require('../../models/callLogModel');
 const { MessageLogModel } = require('../../models/messageLogModel');
 const { UserModel } = require('../../models/userModel');
+const { AccountDataModel } = require('../../models/accountDataModel');
 const connectorRegistry = require('../../connector/registry');
 const oauth = require('../../lib/oauth');
 const { composeCallLog } = require('../../lib/callLogComposer');
@@ -40,12 +41,14 @@ describe('Log Handler', () => {
     await CallLogModel.sync({ force: true });
     await MessageLogModel.sync({ force: true });
     await UserModel.sync({ force: true });
+    await AccountDataModel.sync({ force: true });
   });
 
   afterEach(async () => {
     await CallLogModel.destroy({ where: {} });
     await MessageLogModel.destroy({ where: {} });
     await UserModel.destroy({ where: {} });
+    await AccountDataModel.destroy({ where: {} });
     jest.clearAllMocks();
   });
 
@@ -742,6 +745,228 @@ describe('Log Handler', () => {
       expect(mockConnector.createMessageLog).toHaveBeenCalledTimes(0);
       expect(mockConnector.updateMessageLog).toHaveBeenCalledTimes(1);
     });
+
+    test('should handle group SMS with contactId suffix for message IDs', async () => {
+      // Arrange - group SMS has multiple correspondents
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        rcAccountId: 'rc-account-123',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        createMessageLog: jest.fn().mockResolvedValue({
+          logId: 'msg-log-group-123',
+          returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
+        }),
+        updateMessageLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const incomingData = {
+        logInfo: {
+          messages: [{ id: 'msg-group-1', subject: 'Group SMS', direction: 'Outbound', creationTime: new Date() }],
+          correspondents: [
+            { phoneNumber: '+1234567890' },
+            { phoneNumber: '+0987654321' }
+          ],
+          conversationId: 'conv-group-123',
+          conversationLogId: 'conv-log-group-123'
+        },
+        contactId: 'contact-456',
+        contactType: 'Contact',
+        contactName: 'Primary Contact',
+        additionalSubmission: {}
+      };
+
+      // Act
+      const result = await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logIds).toContain('msg-group-1-contact-456');
+      const savedLog = await MessageLogModel.findOne({ where: { id: 'msg-group-1-contact-456' } });
+      expect(savedLog).not.toBeNull();
+      expect(savedLog.thirdPartyLogId).toBe('msg-log-group-123');
+    });
+
+    test('should pass correspondents to createMessageLog when group SMS has different contact names', async () => {
+      // Arrange - correspondent in cache with different name
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        rcAccountId: 'rc-account-123',
+        platformAdditionalInfo: {}
+      });
+
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-123',
+        platformName: 'testCRM',
+        dataKey: 'contact-+0987654321',
+        data: [{ name: 'Other Contact', id: 'contact-789' }]
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        createMessageLog: jest.fn().mockResolvedValue({
+          logId: 'msg-log-correspondents',
+          returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
+        }),
+        updateMessageLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const incomingData = {
+        logInfo: {
+          messages: [{ id: 'msg-correspondents', subject: 'Group SMS', direction: 'Outbound', creationTime: new Date() }],
+          correspondents: [
+            { phoneNumber: '+1234567890' },
+            { phoneNumber: '+0987654321' }
+          ],
+          conversationId: 'conv-correspondents',
+          conversationLogId: 'conv-log-correspondents'
+        },
+        contactId: 'contact-456',
+        contactType: 'Contact',
+        contactName: 'Primary Contact',
+        additionalSubmission: {}
+      };
+
+      // Act
+      await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData
+      });
+
+      // Assert - createMessageLog should receive correspondents with different name
+      expect(mockConnector.createMessageLog).toHaveBeenCalledWith(
+        expect.objectContaining({
+          correspondents: [[{ name: 'Other Contact', id: 'contact-789' }]]
+        })
+      );
+    });
+
+    test('should not add correspondent when name matches contactName in group SMS', async () => {
+      // Arrange - correspondent in cache with same name as contactName
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        rcAccountId: 'rc-account-123',
+        platformAdditionalInfo: {}
+      });
+
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-123',
+        platformName: 'testCRM',
+        dataKey: 'contact-+0987654321',
+        data: [{ name: 'Primary Contact', id: 'contact-789' }]
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        createMessageLog: jest.fn().mockResolvedValue({
+          logId: 'msg-log-same-name',
+          returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
+        }),
+        updateMessageLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const incomingData = {
+        logInfo: {
+          messages: [{ id: 'msg-same-name', subject: 'Group SMS', direction: 'Outbound', creationTime: new Date() }],
+          correspondents: [
+            { phoneNumber: '+1234567890' },
+            { phoneNumber: '+0987654321' }
+          ],
+          conversationId: 'conv-same-name',
+          conversationLogId: 'conv-log-same-name'
+        },
+        contactId: 'contact-456',
+        contactType: 'Contact',
+        contactName: 'Primary Contact',
+        additionalSubmission: {}
+      };
+
+      // Act
+      await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData
+      });
+
+      // Assert - correspondents should be empty when names match
+      expect(mockConnector.createMessageLog).toHaveBeenCalledWith(
+        expect.objectContaining({
+          correspondents: []
+        })
+      );
+    });
+
+    test('should use suffixed conversationLogId and conversationId for group SMS', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        rcAccountId: 'rc-account-123',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        createMessageLog: jest.fn().mockResolvedValue({
+          logId: 'msg-log-suffix',
+          returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
+        }),
+        updateMessageLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const incomingData = {
+        logInfo: {
+          messages: [{ id: 'msg-suffix', subject: 'Group SMS', direction: 'Outbound', creationTime: new Date() }],
+          correspondents: [
+            { phoneNumber: '+1234567890' },
+            { phoneNumber: '+0987654321' }
+          ],
+          conversationId: 'conv-original',
+          conversationLogId: 'conv-log-original'
+        },
+        contactId: 'contact-999',
+        contactType: 'Contact',
+        contactName: 'Test Contact',
+        additionalSubmission: {}
+      };
+
+      // Act
+      const result = await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData
+      });
+
+      // Assert - message log saved with suffixed conversationLogId
+      expect(result.successful).toBe(true);
+      const savedLog = await MessageLogModel.findOne({ where: { id: 'msg-suffix-contact-999' } });
+      expect(savedLog).not.toBeNull();
+      expect(savedLog.conversationLogId).toBe('conv-log-original-contact-999');
+      expect(savedLog.conversationId).toBe('conv-original-contact-999');
+    });
   });
 
   describe('saveNoteCache', () => {

package/test/setup.js

@@ -1,176 +1,176 @@
-// Test setup for @app-connect/core package
-const path = require('path');
-require('dotenv').config({ path: path.resolve(__dirname, '../.env.test') });
-
-// Set test timeout
-jest.setTimeout(30000);
-
-// Mock console methods to reduce noise in tests
-global.console = {
-  ...console,
-  log: jest.fn(),
-  debug: jest.fn(),
-  info: jest.fn(),
-  warn: jest.fn(),
-  error: jest.fn(),
-};
-
-// Setup database models for testing
-beforeAll(async () => {
-  try {
-    // Set up test database URL if not provided
-    if (!process.env.DATABASE_URL) {
-      process.env.DATABASE_URL = 'sqlite::memory:';
-    }
-
-    // Import models
-    const { CallLogModel } = require('../models/callLogModel');
-    const { MessageLogModel } = require('../models/messageLogModel');
-    const { UserModel } = require('../models/userModel');
-    const { CacheModel } = require('../models/cacheModel');
-    const { AdminConfigModel } = require('../models/adminConfigModel');
-
-    // Sync database models
-    await CallLogModel.sync({ force: true });
-    await MessageLogModel.sync({ force: true });
-    await UserModel.sync({ force: true });
-    await CacheModel.sync({ force: true });
-    await AdminConfigModel.sync({ force: true });
-
-    console.log('Database models synced for testing');
-  } catch (error) {
-    console.error('Error setting up test database:', error);
-    // Don't fail the setup, some tests might not need database
-  }
-});
-
-// Clean up after all tests
-afterAll(async () => {
-  try {
-    // Close database connections
-    const { sequelize } = require('../models/sequelize');
-    if (sequelize) {
-      await sequelize.close();
-    }
-  } catch (error) {
-    console.error('Error closing database connection:', error);
-  }
-});
-
-// Global test utilities
-global.testUtils = {
-  // Helper to create mock user
-  createMockUser: (overrides = {}) => ({
-    id: 'test-user-id',
-    platform: 'testCRM',
-    accessToken: 'test-access-token',
-    refreshToken: 'test-refresh-token',
-    tokenExpiry: new Date(Date.now() + 3600000), // 1 hour from now
-    platformUserInfo: {
-      id: 'test-platform-user-id',
-      name: 'Test User',
-      timezoneName: 'America/Los_Angeles',
-      timezoneOffset: 0,
-      platformAdditionalInfo: {}
-    },
-    ...overrides
-  }),
-
-  // Helper to create mock call log
-  createMockCallLog: (overrides = {}) => ({
-    id: 'test-call-log-id',
-    userId: 'test-user-id',
-    platform: 'testCRM',
-    thirdPartyLogId: 'test-third-party-id',
-    contactId: 'test-contact-id',
-    contactType: 'Contact',
-    phoneNumber: '+1234567890',
-    callDirection: 'Inbound',
-    callResult: 'Answered',
-    callDuration: 120,
-    callStartTime: new Date(),
-    callEndTime: new Date(Date.now() + 120000),
-    recordingLink: 'https://example.com/recording.mp3',
-    subject: 'Test Call',
-    note: 'Test call note',
-    ...overrides
-  }),
-
-  // Helper to create mock contact
-  createMockContact: (overrides = {}) => ({
-    id: 'test-contact-id',
-    name: 'Test Contact',
-    type: 'Contact',
-    phone: '+1234567890',
-    additionalInfo: null,
-    ...overrides
-  }),
-
-  // Helper to reset connector registry
-  resetConnectorRegistry: () => {
-    const connectorRegistry = require('../connector/registry');
-    connectorRegistry.connectors.clear();
-    connectorRegistry.manifests.clear();
-    connectorRegistry.platformInterfaces.clear();
-    connectorRegistry.releaseNotes = {};
-  },
-
-  // Helper to create mock connector
-  createMockConnector: (overrides = {}) => ({
-    getAuthType: jest.fn().mockReturnValue('apiKey'),
-    getUserInfo: jest.fn().mockResolvedValue({
-      successful: true,
-      platformUserInfo: {
-        id: 'test-user-id',
-        name: 'Test User',
-        timezoneName: 'America/Los_Angeles',
-        timezoneOffset: 0,
-        platformAdditionalInfo: {}
-      }
-    }),
-    createCallLog: jest.fn().mockResolvedValue({
-      logId: 'test-log-id',
-      returnMessage: {
-        message: 'Call logged successfully',
-        messageType: 'success',
-        ttl: 2000
-      }
-    }),
-    updateCallLog: jest.fn().mockResolvedValue({
-      updatedNote: 'Call log updated',
-      returnMessage: {
-        message: 'Call log updated successfully',
-        messageType: 'success',
-        ttl: 2000
-      }
-    }),
-    unAuthorize: jest.fn().mockResolvedValue({
-      returnMessage: {
-        messageType: 'success',
-        message: 'Logged out successfully',
-        ttl: 1000
-      }
-    }),
-    findContact: jest.fn().mockResolvedValue([
-      {
-        id: 'test-contact-id',
-        name: 'Test Contact',
-        type: 'Contact',
-        phone: '+1234567890',
-        additionalInfo: null
-      }
-    ]),
-    createContact: jest.fn().mockResolvedValue({
-      contactInfo: {
-        id: 'new-contact-id',
-        name: 'New Contact'
-      },
-      returnMessage: {
-        message: 'Contact created successfully',
-        messageType: 'success',
-        ttl: 2000
-      }
-    }),
-    ...overrides
-  })
-};
+// Test setup for @app-connect/core package
+const path = require('path');
+require('dotenv').config({ path: path.resolve(__dirname, '../.env.test') });
+
+// Set test timeout
+jest.setTimeout(30000);
+
+// Mock console methods to reduce noise in tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+};
+
+// Setup database models for testing
+beforeAll(async () => {
+  try {
+    // Set up test database URL if not provided
+    if (!process.env.DATABASE_URL) {
+      process.env.DATABASE_URL = 'sqlite::memory:';
+    }
+
+    // Import models
+    const { CallLogModel } = require('../models/callLogModel');
+    const { MessageLogModel } = require('../models/messageLogModel');
+    const { UserModel } = require('../models/userModel');
+    const { CacheModel } = require('../models/cacheModel');
+    const { AdminConfigModel } = require('../models/adminConfigModel');
+
+    // Sync database models
+    await CallLogModel.sync({ force: true });
+    await MessageLogModel.sync({ force: true });
+    await UserModel.sync({ force: true });
+    await CacheModel.sync({ force: true });
+    await AdminConfigModel.sync({ force: true });
+
+    console.log('Database models synced for testing');
+  } catch (error) {
+    console.error('Error setting up test database:', error);
+    // Don't fail the setup, some tests might not need database
+  }
+});
+
+// Clean up after all tests
+afterAll(async () => {
+  try {
+    // Close database connections
+    const { sequelize } = require('../models/sequelize');
+    if (sequelize) {
+      await sequelize.close();
+    }
+  } catch (error) {
+    console.error('Error closing database connection:', error);
+  }
+});
+
+// Global test utilities
+global.testUtils = {
+  // Helper to create mock user
+  createMockUser: (overrides = {}) => ({
+    id: 'test-user-id',
+    platform: 'testCRM',
+    accessToken: 'test-access-token',
+    refreshToken: 'test-refresh-token',
+    tokenExpiry: new Date(Date.now() + 3600000), // 1 hour from now
+    platformUserInfo: {
+      id: 'test-platform-user-id',
+      name: 'Test User',
+      timezoneName: 'America/Los_Angeles',
+      timezoneOffset: 0,
+      platformAdditionalInfo: {}
+    },
+    ...overrides
+  }),
+
+  // Helper to create mock call log
+  createMockCallLog: (overrides = {}) => ({
+    id: 'test-call-log-id',
+    userId: 'test-user-id',
+    platform: 'testCRM',
+    thirdPartyLogId: 'test-third-party-id',
+    contactId: 'test-contact-id',
+    contactType: 'Contact',
+    phoneNumber: '+1234567890',
+    callDirection: 'Inbound',
+    callResult: 'Answered',
+    callDuration: 120,
+    callStartTime: new Date(),
+    callEndTime: new Date(Date.now() + 120000),
+    recordingLink: 'https://example.com/recording.mp3',
+    subject: 'Test Call',
+    note: 'Test call note',
+    ...overrides
+  }),
+
+  // Helper to create mock contact
+  createMockContact: (overrides = {}) => ({
+    id: 'test-contact-id',
+    name: 'Test Contact',
+    type: 'Contact',
+    phone: '+1234567890',
+    additionalInfo: null,
+    ...overrides
+  }),
+
+  // Helper to reset connector registry
+  resetConnectorRegistry: () => {
+    const connectorRegistry = require('../connector/registry');
+    connectorRegistry.connectors.clear();
+    connectorRegistry.manifests.clear();
+    connectorRegistry.platformInterfaces.clear();
+    connectorRegistry.releaseNotes = {};
+  },
+
+  // Helper to create mock connector
+  createMockConnector: (overrides = {}) => ({
+    getAuthType: jest.fn().mockReturnValue('apiKey'),
+    getUserInfo: jest.fn().mockResolvedValue({
+      successful: true,
+      platformUserInfo: {
+        id: 'test-user-id',
+        name: 'Test User',
+        timezoneName: 'America/Los_Angeles',
+        timezoneOffset: 0,
+        platformAdditionalInfo: {}
+      }
+    }),
+    createCallLog: jest.fn().mockResolvedValue({
+      logId: 'test-log-id',
+      returnMessage: {
+        message: 'Call logged successfully',
+        messageType: 'success',
+        ttl: 2000
+      }
+    }),
+    updateCallLog: jest.fn().mockResolvedValue({
+      updatedNote: 'Call log updated',
+      returnMessage: {
+        message: 'Call log updated successfully',
+        messageType: 'success',
+        ttl: 2000
+      }
+    }),
+    unAuthorize: jest.fn().mockResolvedValue({
+      returnMessage: {
+        messageType: 'success',
+        message: 'Logged out successfully',
+        ttl: 1000
+      }
+    }),
+    findContact: jest.fn().mockResolvedValue([
+      {
+        id: 'test-contact-id',
+        name: 'Test Contact',
+        type: 'Contact',
+        phone: '+1234567890',
+        additionalInfo: null
+      }
+    ]),
+    createContact: jest.fn().mockResolvedValue({
+      contactInfo: {
+        id: 'new-contact-id',
+        name: 'New Contact'
+      },
+      returnMessage: {
+        message: 'Contact created successfully',
+        messageType: 'success',
+        ttl: 2000
+      }
+    }),
+    ...overrides
+  })
+};