@app-connect/core 1.7.25 → 1.7.26

package/test/handlers/log.test.js

@@ -1,1160 +1,1298 @@
-// Use in-memory SQLite for isolated model tests
-jest.mock('../../models/sequelize', () => {
-  const { Sequelize } = require('sequelize');
-  return {
-    sequelize: new Sequelize({
-      dialect: 'sqlite',
-      storage: ':memory:',
-      logging: false,
-    }),
-  };
-});
-
-jest.mock('../../connector/registry');
-jest.mock('../../lib/oauth');
-jest.mock('../../lib/callLogComposer');
-jest.mock('../../models/dynamo/noteCacheSchema', () => ({
-  NoteCache: {
-    get: jest.fn(),
-    create: jest.fn()
-  }
-}));
-jest.mock('../../models/dynamo/connectorSchema', () => ({
-  Connector: {
-    getProxyConfig: jest.fn()
-  }
-}));
-jest.mock('axios');
-
-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');
-const { NoteCache } = require('../../models/dynamo/noteCacheSchema');
-const axios = require('axios');
-const { sequelize } = require('../../models/sequelize');
-
-describe('Log Handler', () => {
-  beforeAll(async () => {
-    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();
-  });
-
-  afterAll(async () => {
-    await sequelize.close();
-  });
-
-  describe('createCallLog', () => {
-    const mockUser = {
-      id: 'test-user-id',
-      platform: 'testCRM',
-      accessToken: 'test-access-token',
-      rcAccountId: '12345',
-      platformAdditionalInfo: {}
-    };
-
-    const mockIncomingData = {
-      logInfo: {
-        sessionId: 'session-123',
-        telephonySessionId: 'tel-session-123',
-        id: 'call-id-123',
-        direction: 'Outbound',
-        startTime: new Date().toISOString(),
-        duration: 120,
-        result: 'Completed',
-        from: { phoneNumber: '+1234567890' },
-        to: { phoneNumber: '+0987654321' },
-        recording: { link: 'https://recording.link' }
-      },
-      contactId: 'contact-123',
-      contactType: 'Contact',
-      contactName: 'Test Contact',
-      note: 'Test note',
-      aiNote: '',
-      transcript: '',
-      additionalSubmission: {}
-    };
-
-    test('should return warning when call log already exists for session', async () => {
-      // Arrange
-      await CallLogModel.create({
-        id: 'existing-log',
-        sessionId: 'session-123',
-        platform: 'testCRM',
-        thirdPartyLogId: 'third-party-123',
-        userId: 'test-user-id'
-      });
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.messageType).toBe('warning');
-      expect(result.returnMessage.message).toContain('Existing log for session');
-    });
-
-    test('should return warning when user not found', async () => {
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'non-existent-user',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toBe('User not found');
-    });
-
-    test('should return warning when user has no access token', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: null
-      });
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toBe('User not found');
-    });
-
-    test('should return warning when contact not found', async () => {
-      // Arrange
-      await UserModel.create(mockUser);
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Composed log details');
-
-      const incomingDataNoContact = {
-        ...mockIncomingData,
-        contactId: null
-      };
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: incomingDataNoContact,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toContain('Contact not found for number');
-    });
-
-    test('should successfully create call log with apiKey auth', async () => {
-      // Arrange
-      await UserModel.create(mockUser);
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn().mockResolvedValue({
-          logId: 'new-log-123',
-          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Composed log details');
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logId).toBe('new-log-123');
-      expect(mockConnector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'test-access-token' });
-      expect(mockConnector.createCallLog).toHaveBeenCalled();
-
-      // Verify call log was saved to database
-      const savedLog = await CallLogModel.findOne({ where: { sessionId: 'session-123' } });
-      expect(savedLog).not.toBeNull();
-      expect(savedLog.thirdPartyLogId).toBe('new-log-123');
-    });
-
-    test('should call plugin with Bearer auth and without query jwt token', async () => {
-      await UserModel.create(mockUser);
-      await AccountDataModel.create({
-        rcAccountId: mockUser.rcAccountId,
-        platformName: 'testPlugin',
-        dataKey: 'pluginData',
-        data: {
-          name: 'plugin.sample',
-          supportedLogTypes: ['call'],
-          isAsync: false,
-          endpointUrl: 'https://plugins.example.com/plugin/testPlugin',
-          jwtToken: 'plugin-jwt-token'
-        }
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn().mockResolvedValue({
-          logId: 'new-log-123',
-          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Composed log details');
-
-      axios.post.mockResolvedValue({
-        data: {
-          ...mockIncomingData,
-          note: 'updated by plugin'
-        },
-        headers: {
-          'x-refreshed-jwt-token': 'refreshed-plugin-jwt'
-        }
-      });
-
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      expect(result.successful).toBe(true);
-      expect(axios.post).toHaveBeenCalledWith(
-        'https://plugins.example.com/plugin/testPlugin',
-        { data: mockIncomingData, config: null },
-        {
-          headers: {
-            Authorization: 'Bearer plugin-jwt-token'
-          }
-        }
-      );
-    });
-
-    test('should successfully create call log with oauth auth', async () => {
-      // Arrange
-      const oauthUser = { ...mockUser };
-      await UserModel.create(oauthUser);
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('oauth'),
-        getOauthInfo: jest.fn().mockResolvedValue({
-          clientId: 'client-id',
-          clientSecret: 'client-secret',
-          accessTokenUri: 'https://token.url',
-          authorizationUri: 'https://auth.url'
-        }),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn().mockResolvedValue({
-          logId: 'oauth-log-123',
-          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      const mockOAuthApp = {};
-      oauth.getOAuthApp.mockReturnValue(mockOAuthApp);
-      oauth.checkAndRefreshAccessToken.mockResolvedValue({
-        ...oauthUser,
-        accessToken: 'refreshed-token'
-      });
-      composeCallLog.mockReturnValue('Composed log details');
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logId).toBe('oauth-log-123');
-      expect(oauth.checkAndRefreshAccessToken).toHaveBeenCalled();
-    });
-
-    test('should use cached note when USE_CACHE is enabled and isFromSSCL', async () => {
-      // Arrange
-      process.env.USE_CACHE = 'true';
-      await UserModel.create(mockUser);
-
-      NoteCache.get.mockResolvedValue({ note: 'Cached note' });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn().mockResolvedValue({
-          logId: 'cached-log-123',
-          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Composed log details');
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: mockIncomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: true
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(NoteCache.get).toHaveBeenCalledWith({ sessionId: 'session-123' });
-
-      // Clean up
-      delete process.env.USE_CACHE;
-    });
-  });
-
-  describe('getCallLog', () => {
-    test('should return error when user not found', async () => {
-      // Act
-      const result = await logHandler.getCallLog({
-        userId: 'non-existent-user',
-        sessionIds: 'session-1,session-2',
-        platform: 'testCRM',
-        requireDetails: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.message).toBe('Contact not found');
-    });
-
-    test('should return error when no session IDs provided', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token'
-      });
-
-      // Act
-      const result = await logHandler.getCallLog({
-        userId: 'test-user-id',
-        sessionIds: null,
-        platform: 'testCRM',
-        requireDetails: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.message).toBe('No session IDs provided');
-    });
-
-    test('should return matched logs without details', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token'
-      });
-
-      await CallLogModel.create({
-        id: 'call-1',
-        sessionId: 'session-1',
-        platform: 'testCRM',
-        thirdPartyLogId: 'log-1',
-        userId: 'test-user-id'
-      });
-
-      // Act
-      const result = await logHandler.getCallLog({
-        userId: 'test-user-id',
-        sessionIds: 'session-1,session-2',
-        platform: 'testCRM',
-        requireDetails: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logs).toHaveLength(2);
-      expect(result.logs[0]).toEqual({
-        sessionId: 'session-1',
-        matched: true,
-        logId: 'log-1'
-      });
-      expect(result.logs[1]).toEqual({
-        sessionId: 'session-2',
-        matched: false
-      });
-    });
-
-    test('should return matched logs with details when requireDetails is true', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      await CallLogModel.create({
-        id: 'call-1',
-        sessionId: 'session-1',
-        platform: 'testCRM',
-        thirdPartyLogId: 'log-1',
-        userId: 'test-user-id',
-        contactId: 'contact-1'
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getCallLog: jest.fn().mockResolvedValue({
-          callLogInfo: { subject: 'Test Call', note: 'Test note' },
-          returnMessage: { message: 'Success', messageType: 'success' }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      // Act
-      const result = await logHandler.getCallLog({
-        userId: 'test-user-id',
-        sessionIds: 'session-1',
-        platform: 'testCRM',
-        requireDetails: true
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logs).toHaveLength(1);
-      expect(result.logs[0].matched).toBe(true);
-      expect(result.logs[0].logData).toEqual({ subject: 'Test Call', note: 'Test note' });
-      expect(mockConnector.getCallLog).toHaveBeenCalled();
-    });
-
-    test('should limit session IDs to 5', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token'
-      });
-
-      const sessionIds = 'session-1,session-2,session-3,session-4,session-5,session-6,session-7';
-
-      // Act
-      const result = await logHandler.getCallLog({
-        userId: 'test-user-id',
-        sessionIds,
-        platform: 'testCRM',
-        requireDetails: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logs).toHaveLength(5);
-    });
-
-    test('should skip session ID 0', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getCallLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      // Act
-      const result = await logHandler.getCallLog({
-        userId: 'test-user-id',
-        sessionIds: '0,session-1',
-        platform: 'testCRM',
-        requireDetails: true
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logs[0]).toEqual({ sessionId: '0', matched: false });
-    });
-  });
-
-  describe('updateCallLog', () => {
-    test('should return unsuccessful when no existing call log found', async () => {
-      // Act
-      const result = await logHandler.updateCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: { sessionId: 'non-existent-session' },
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-    });
-
-    test('should return error when user not found for update', async () => {
-      // Arrange
-      await CallLogModel.create({
-        id: 'call-1',
-        sessionId: 'session-1',
-        platform: 'testCRM',
-        thirdPartyLogId: 'log-1',
-        userId: 'test-user-id'
-      });
-
-      // Act
-      const result = await logHandler.updateCallLog({
-        platform: 'testCRM',
-        userId: 'non-existent-user',
-        incomingData: { sessionId: 'session-1' },
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.message).toBe('Contact not found');
-    });
-
-    test('should successfully update call log', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      await CallLogModel.create({
-        id: 'call-1',
-        sessionId: 'session-1',
-        platform: 'testCRM',
-        thirdPartyLogId: 'log-1',
-        userId: 'test-user-id',
-        contactId: 'contact-1'
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        getCallLog: jest.fn().mockResolvedValue({
-          callLogInfo: { fullBody: 'Existing body', note: 'Existing note' }
-        }),
-        updateCallLog: jest.fn().mockResolvedValue({
-          updatedNote: 'Updated note',
-          returnMessage: { message: 'Updated', messageType: 'success', ttl: 2000 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Updated composed log');
-
-      const incomingData = {
-        sessionId: 'session-1',
-        note: 'Updated note',
-        subject: 'Updated subject',
-        startTime: new Date().toISOString(),
-        duration: 180,
-        result: 'Completed'
-      };
-
-      // Act
-      const result = await logHandler.updateCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.logId).toBe('log-1');
-      expect(result.updatedNote).toBe('Updated note');
-      expect(mockConnector.updateCallLog).toHaveBeenCalled();
-    });
-  });
-
-  describe('createMessageLog', () => {
-    test('should return warning when no messages to log', async () => {
-      // Act
-      const result = await logHandler.createMessageLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: {
-          logInfo: { messages: [] }
-        }
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toBe('No message to log.');
-    });
-
-    test('should return warning when user not found', async () => {
-      // Act
-      const result = await logHandler.createMessageLog({
-        platform: 'testCRM',
-        userId: 'non-existent-user',
-        incomingData: {
-          logInfo: {
-            messages: [{ id: 'msg-1', subject: 'Test', creationTime: new Date() }],
-            correspondents: [{ phoneNumber: '+1234567890' }]
-          }
-        }
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toBe('Contact not found');
-    });
-
-    test('should return warning when contact not found', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded')
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      // Act
-      const result = await logHandler.createMessageLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData: {
-          logInfo: {
-            messages: [{ id: 'msg-1', subject: 'Test', creationTime: new Date() }],
-            correspondents: [{ phoneNumber: '+1234567890' }]
-          },
-          contactId: null
-        }
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toContain('Contact not found for number');
-    });
-
-    test('should successfully create message log', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        createMessageLog: jest.fn().mockResolvedValue({
-          logId: 'msg-log-123',
-          returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
-        }),
-        updateMessageLog: jest.fn()
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      const incomingData = {
-        logInfo: {
-          messages: [{ id: 'msg-1', subject: 'Test SMS', direction: 'Outbound', creationTime: new Date() }],
-          correspondents: [{ phoneNumber: '+1234567890' }],
-          conversationId: 'conv-123',
-          conversationLogId: 'conv-log-123'
-        },
-        contactId: 'contact-123',
-        contactType: 'Contact',
-        contactName: 'Test 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-1');
-      expect(mockConnector.createMessageLog).toHaveBeenCalled();
-
-      // Verify message log was saved
-      const savedLog = await MessageLogModel.findOne({ where: { id: 'msg-1' } });
-      expect(savedLog).not.toBeNull();
-      expect(savedLog.thirdPartyLogId).toBe('msg-log-123');
-    });
-
-    test('should skip already logged messages', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        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'
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        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);
-
-      const incomingData = {
-        logInfo: {
-          messages: [
-            { id: 'msg-1', subject: 'Already logged', direction: 'Outbound', creationTime: new Date() },
-            { id: 'msg-2', subject: 'New message', direction: 'Outbound', creationTime: new Date() }
-          ],
-          correspondents: [{ phoneNumber: '+1234567890' }],
-          conversationId: 'conv-123',
-          conversationLogId: 'conv-log-123'  // Same conversationLogId as existing record
-        },
-        contactId: 'contact-123',
-        contactType: 'Contact',
-        additionalSubmission: {}
-      };
-
-      // Act
-      const result = await logHandler.createMessageLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      // msg-1 is skipped (already logged), msg-2 uses updateMessageLog because same conversationLogId exists
-      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', () => {
-    test('should successfully save note cache', async () => {
-      // Arrange
-      NoteCache.create.mockResolvedValue({ sessionId: 'session-123', note: 'Test note' });
-
-      // Act
-      const result = await logHandler.saveNoteCache({
-        sessionId: 'session-123',
-        note: 'Test note'
-      });
-
-      // Assert
-      expect(result.successful).toBe(true);
-      expect(result.returnMessage).toBe('Note cache saved');
-      expect(NoteCache.create).toHaveBeenCalled();
-    });
-
-    test('should handle errors when saving note cache', async () => {
-      // Arrange
-      NoteCache.create.mockRejectedValue(new Error('DynamoDB error'));
-
-      // Act
-      const result = await logHandler.saveNoteCache({
-        sessionId: 'session-123',
-        note: 'Test note'
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.message).toBe('Error performing saveNoteCache');
-      expect(result.returnMessage.messageType).toBe('warning');
-    });
-  });
-
-  describe('Error Handling', () => {
-    test('should handle 429 rate limit error in createCallLog', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn().mockRejectedValue({
-          response: { status: 429 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Composed log');
-
-      const incomingData = {
-        logInfo: {
-          sessionId: 'session-rate-limit',
-          telephonySessionId: 'tel-session',
-          direction: 'Outbound',
-          from: { phoneNumber: '+1234567890' },
-          to: { phoneNumber: '+0987654321' }
-        },
-        contactId: 'contact-123',
-        note: 'Test'
-      };
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.returnMessage.messageType).toBe('warning');
-    });
-
-    test('should handle 401 authorization error in createCallLog', async () => {
-      // Arrange
-      await UserModel.create({
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-token',
-        platformAdditionalInfo: {}
-      });
-
-      const mockConnector = {
-        getAuthType: jest.fn().mockResolvedValue('apiKey'),
-        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
-        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
-        createCallLog: jest.fn().mockRejectedValue({
-          response: { status: 401 }
-        })
-      };
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-      composeCallLog.mockReturnValue('Composed log');
-
-      const incomingData = {
-        logInfo: {
-          sessionId: 'session-auth-error',
-          telephonySessionId: 'tel-session',
-          direction: 'Outbound',
-          from: { phoneNumber: '+1234567890' },
-          to: { phoneNumber: '+0987654321' }
-        },
-        contactId: 'contact-123',
-        note: 'Test'
-      };
-
-      // Act
-      const result = await logHandler.createCallLog({
-        platform: 'testCRM',
-        userId: 'test-user-id',
-        incomingData,
-        hashedAccountId: 'hashed-123',
-        isFromSSCL: false
-      });
-
-      // Assert
-      expect(result.successful).toBe(false);
-      expect(result.extraDataTracking.statusCode).toBe(401);
-    });
-  });
-});
-
+// Use in-memory SQLite for isolated model tests
+jest.mock('../../models/sequelize', () => {
+  const { Sequelize } = require('sequelize');
+  return {
+    sequelize: new Sequelize({
+      dialect: 'sqlite',
+      storage: ':memory:',
+      logging: false,
+    }),
+  };
+});
+
+jest.mock('../../connector/registry');
+jest.mock('../../lib/oauth');
+jest.mock('../../lib/callLogComposer');
+jest.mock('../../models/dynamo/noteCacheSchema', () => ({
+  NoteCache: {
+    get: jest.fn(),
+    create: jest.fn()
+  }
+}));
+jest.mock('../../models/dynamo/connectorSchema', () => ({
+  Connector: {
+    getProxyConfig: jest.fn()
+  }
+}));
+jest.mock('axios');
+
+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');
+const { NoteCache } = require('../../models/dynamo/noteCacheSchema');
+const axios = require('axios');
+const { sequelize } = require('../../models/sequelize');
+
+describe('Log Handler', () => {
+  beforeAll(async () => {
+    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();
+  });
+
+  afterAll(async () => {
+    await sequelize.close();
+  });
+
+  describe('createCallLog', () => {
+    const mockUser = {
+      id: 'test-user-id',
+      platform: 'testCRM',
+      accessToken: 'test-access-token',
+      rcAccountId: '12345',
+      platformAdditionalInfo: {}
+    };
+
+    const mockIncomingData = {
+      logInfo: {
+        sessionId: 'session-123',
+        telephonySessionId: 'tel-session-123',
+        id: 'call-id-123',
+        direction: 'Outbound',
+        startTime: new Date().toISOString(),
+        duration: 120,
+        result: 'Completed',
+        from: { phoneNumber: '+1234567890' },
+        to: { phoneNumber: '+0987654321' },
+        recording: { link: 'https://recording.link' }
+      },
+      contactId: 'contact-123',
+      contactType: 'Contact',
+      contactName: 'Test Contact',
+      note: 'Test note',
+      aiNote: '',
+      transcript: '',
+      additionalSubmission: {}
+    };
+
+    test('should return warning when call log already exists for session', async () => {
+      // Arrange
+      await CallLogModel.create({
+        id: 'existing-log',
+        sessionId: 'session-123',
+        platform: 'testCRM',
+        thirdPartyLogId: 'third-party-123',
+        userId: 'test-user-id'
+      });
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.messageType).toBe('warning');
+      expect(result.returnMessage.message).toContain('Existing log for session');
+    });
+
+    test('should allow same session when extensionNumber is different', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+      await CallLogModel.create({
+        id: 'tel-session-123',
+        sessionId: 'session-123',
+        extensionNumber: '101',
+        platform: 'testCRM',
+        thirdPartyLogId: 'third-party-101',
+        userId: 'test-user-id'
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockResolvedValue({
+          logId: 'new-log-102',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      const incomingData = {
+        ...mockIncomingData,
+        logInfo: {
+          ...mockIncomingData.logInfo,
+          extensionNumber: '102'
+        }
+      };
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      const savedLog = await CallLogModel.findOne({
+        where: {
+          sessionId: 'session-123',
+          extensionNumber: '102'
+        }
+      });
+      expect(savedLog).not.toBeNull();
+      expect(savedLog.thirdPartyLogId).toBe('new-log-102');
+    });
+
+    test('should return warning when user not found', async () => {
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'non-existent-user',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toBe('User not found');
+    });
+
+    test('should return warning when user has no access token', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: null
+      });
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toBe('User not found');
+    });
+
+    test('should return warning when contact not found', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      const incomingDataNoContact = {
+        ...mockIncomingData,
+        contactId: null
+      };
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: incomingDataNoContact,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toContain('Contact not found for number');
+    });
+
+    test('should successfully create call log with apiKey auth', async () => {
+      // Arrange
+      await UserModel.create(mockUser);
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockResolvedValue({
+          logId: 'new-log-123',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logId).toBe('new-log-123');
+      expect(mockConnector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'test-access-token' });
+      expect(mockConnector.createCallLog).toHaveBeenCalled();
+
+      // Verify call log was saved to database
+      const savedLog = await CallLogModel.findOne({ where: { sessionId: 'session-123' } });
+      expect(savedLog).not.toBeNull();
+      expect(savedLog.thirdPartyLogId).toBe('new-log-123');
+    });
+
+    test('should call plugin with Bearer auth and without query jwt token', async () => {
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: mockUser.rcAccountId,
+        platformName: 'testPlugin',
+        dataKey: 'pluginData',
+        data: {
+          name: 'plugin.sample',
+          supportedLogTypes: ['call'],
+          isAsync: false,
+          endpointUrl: 'https://plugins.example.com/plugin/testPlugin',
+          jwtToken: 'plugin-jwt-token'
+        }
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockResolvedValue({
+          logId: 'new-log-123',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      axios.post.mockResolvedValue({
+        data: {
+          ...mockIncomingData,
+          note: 'updated by plugin'
+        },
+        headers: {
+          'x-refreshed-jwt-token': 'refreshed-plugin-jwt'
+        }
+      });
+
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      expect(result.successful).toBe(true);
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://plugins.example.com/plugin/testPlugin',
+        { data: mockIncomingData, config: null },
+        {
+          headers: {
+            Authorization: 'Bearer plugin-jwt-token'
+          }
+        }
+      );
+    });
+
+    test('should successfully create call log with oauth auth', async () => {
+      // Arrange
+      const oauthUser = { ...mockUser };
+      await UserModel.create(oauthUser);
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('oauth'),
+        getOauthInfo: jest.fn().mockResolvedValue({
+          clientId: 'client-id',
+          clientSecret: 'client-secret',
+          accessTokenUri: 'https://token.url',
+          authorizationUri: 'https://auth.url'
+        }),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockResolvedValue({
+          logId: 'oauth-log-123',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const mockOAuthApp = {};
+      oauth.getOAuthApp.mockReturnValue(mockOAuthApp);
+      oauth.checkAndRefreshAccessToken.mockResolvedValue({
+        ...oauthUser,
+        accessToken: 'refreshed-token'
+      });
+      composeCallLog.mockReturnValue('Composed log details');
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logId).toBe('oauth-log-123');
+      expect(oauth.checkAndRefreshAccessToken).toHaveBeenCalled();
+    });
+
+    test('should use cached note when USE_CACHE is enabled and isFromSSCL', async () => {
+      // Arrange
+      process.env.USE_CACHE = 'true';
+      await UserModel.create(mockUser);
+
+      NoteCache.get.mockResolvedValue({ note: 'Cached note' });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockResolvedValue({
+          logId: 'cached-log-123',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: true
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(NoteCache.get).toHaveBeenCalledWith({ sessionId: 'session-123' });
+
+      // Clean up
+      delete process.env.USE_CACHE;
+    });
+  });
+
+  describe('getCallLog', () => {
+    test('should return error when user not found', async () => {
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'non-existent-user',
+        sessionIds: 'session-1,session-2',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.message).toBe('Contact not found');
+    });
+
+    test('should return error when no session IDs provided', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token'
+      });
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: null,
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.message).toBe('No session IDs provided');
+    });
+
+    test('should return matched logs without details', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token'
+      });
+
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-1',
+        userId: 'test-user-id'
+      });
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: 'session-1,session-2',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs).toHaveLength(2);
+      expect(result.logs[0]).toEqual({
+        sessionId: 'session-1',
+        matched: true,
+        logId: 'log-1'
+      });
+      expect(result.logs[1]).toEqual({
+        sessionId: 'session-2',
+        matched: false
+      });
+    });
+
+    test('should filter matched logs by extensionNumber when provided', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token'
+      });
+
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        extensionNumber: '101',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-101',
+        userId: 'test-user-id'
+      });
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        extensionNumber: '102',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-102',
+        userId: 'test-user-id'
+      });
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: 'session-1',
+        extensionNumber: '102',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs).toEqual([{
+        sessionId: 'session-1',
+        matched: true,
+        logId: 'log-102'
+      }]);
+    });
+
+    test('should keep session-only lookup backward compatible when extensionNumber is empty', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token'
+      });
+
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        extensionNumber: '',
+        platform: 'testCRM',
+        thirdPartyLogId: 'legacy-log',
+        userId: 'test-user-id'
+      });
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        extensionNumber: '102',
+        platform: 'testCRM',
+        thirdPartyLogId: 'extension-log',
+        userId: 'test-user-id'
+      });
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: 'session-1',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs).toEqual([{
+        sessionId: 'session-1',
+        matched: true,
+        logId: 'legacy-log'
+      }]);
+    });
+
+    test('should return matched logs with details when requireDetails is true', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-1',
+        userId: 'test-user-id',
+        contactId: 'contact-1'
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getCallLog: jest.fn().mockResolvedValue({
+          callLogInfo: { subject: 'Test Call', note: 'Test note' },
+          returnMessage: { message: 'Success', messageType: 'success' }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: 'session-1',
+        platform: 'testCRM',
+        requireDetails: true
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs).toHaveLength(1);
+      expect(result.logs[0].matched).toBe(true);
+      expect(result.logs[0].logData).toEqual({ subject: 'Test Call', note: 'Test note' });
+      expect(mockConnector.getCallLog).toHaveBeenCalled();
+    });
+
+    test('should limit session IDs to 5', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token'
+      });
+
+      const sessionIds = 'session-1,session-2,session-3,session-4,session-5,session-6,session-7';
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds,
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs).toHaveLength(5);
+    });
+
+    test('should skip session ID 0', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getCallLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: '0,session-1',
+        platform: 'testCRM',
+        requireDetails: true
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs[0]).toEqual({ sessionId: '0', matched: false });
+    });
+  });
+
+  describe('updateCallLog', () => {
+    test('should return unsuccessful when no existing call log found', async () => {
+      // Act
+      const result = await logHandler.updateCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: { sessionId: 'non-existent-session' },
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+    });
+
+    test('should return error when user not found for update', async () => {
+      // Arrange
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-1',
+        userId: 'test-user-id'
+      });
+
+      // Act
+      const result = await logHandler.updateCallLog({
+        platform: 'testCRM',
+        userId: 'non-existent-user',
+        incomingData: { sessionId: 'session-1' },
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.message).toBe('Contact not found');
+    });
+
+    test('should successfully update call log', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-1',
+        userId: 'test-user-id',
+        contactId: 'contact-1'
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        getCallLog: jest.fn().mockResolvedValue({
+          callLogInfo: { fullBody: 'Existing body', note: 'Existing note' }
+        }),
+        updateCallLog: jest.fn().mockResolvedValue({
+          updatedNote: 'Updated note',
+          returnMessage: { message: 'Updated', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Updated composed log');
+
+      const incomingData = {
+        sessionId: 'session-1',
+        note: 'Updated note',
+        subject: 'Updated subject',
+        startTime: new Date().toISOString(),
+        duration: 180,
+        result: 'Completed'
+      };
+
+      // Act
+      const result = await logHandler.updateCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logId).toBe('log-1');
+      expect(result.updatedNote).toBe('Updated note');
+      expect(mockConnector.updateCallLog).toHaveBeenCalled();
+    });
+  });
+
+  describe('createMessageLog', () => {
+    test('should return warning when no messages to log', async () => {
+      // Act
+      const result = await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: {
+          logInfo: { messages: [] }
+        }
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toBe('No message to log.');
+    });
+
+    test('should return warning when user not found', async () => {
+      // Act
+      const result = await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'non-existent-user',
+        incomingData: {
+          logInfo: {
+            messages: [{ id: 'msg-1', subject: 'Test', creationTime: new Date() }],
+            correspondents: [{ phoneNumber: '+1234567890' }]
+          }
+        }
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toBe('Contact not found');
+    });
+
+    test('should return warning when contact not found', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded')
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      // Act
+      const result = await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: {
+          logInfo: {
+            messages: [{ id: 'msg-1', subject: 'Test', creationTime: new Date() }],
+            correspondents: [{ phoneNumber: '+1234567890' }]
+          },
+          contactId: null
+        }
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toContain('Contact not found for number');
+    });
+
+    test('should successfully create message log', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        createMessageLog: jest.fn().mockResolvedValue({
+          logId: 'msg-log-123',
+          returnMessage: { message: 'Message logged', messageType: 'success', ttl: 2000 }
+        }),
+        updateMessageLog: jest.fn()
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const incomingData = {
+        logInfo: {
+          messages: [{ id: 'msg-1', subject: 'Test SMS', direction: 'Outbound', creationTime: new Date() }],
+          correspondents: [{ phoneNumber: '+1234567890' }],
+          conversationId: 'conv-123',
+          conversationLogId: 'conv-log-123'
+        },
+        contactId: 'contact-123',
+        contactType: 'Contact',
+        contactName: 'Test 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-1');
+      expect(mockConnector.createMessageLog).toHaveBeenCalled();
+
+      // Verify message log was saved
+      const savedLog = await MessageLogModel.findOne({ where: { id: 'msg-1' } });
+      expect(savedLog).not.toBeNull();
+      expect(savedLog.thirdPartyLogId).toBe('msg-log-123');
+    });
+
+    test('should skip already logged messages', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        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'
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        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);
+
+      const incomingData = {
+        logInfo: {
+          messages: [
+            { id: 'msg-1', subject: 'Already logged', direction: 'Outbound', creationTime: new Date() },
+            { id: 'msg-2', subject: 'New message', direction: 'Outbound', creationTime: new Date() }
+          ],
+          correspondents: [{ phoneNumber: '+1234567890' }],
+          conversationId: 'conv-123',
+          conversationLogId: 'conv-log-123'  // Same conversationLogId as existing record
+        },
+        contactId: 'contact-123',
+        contactType: 'Contact',
+        additionalSubmission: {}
+      };
+
+      // Act
+      const result = await logHandler.createMessageLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      // msg-1 is skipped (already logged), msg-2 uses updateMessageLog because same conversationLogId exists
+      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', () => {
+    test('should successfully save note cache', async () => {
+      // Arrange
+      NoteCache.create.mockResolvedValue({ sessionId: 'session-123', note: 'Test note' });
+
+      // Act
+      const result = await logHandler.saveNoteCache({
+        sessionId: 'session-123',
+        note: 'Test note'
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.returnMessage).toBe('Note cache saved');
+      expect(NoteCache.create).toHaveBeenCalled();
+    });
+
+    test('should handle errors when saving note cache', async () => {
+      // Arrange
+      NoteCache.create.mockRejectedValue(new Error('DynamoDB error'));
+
+      // Act
+      const result = await logHandler.saveNoteCache({
+        sessionId: 'session-123',
+        note: 'Test note'
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.message).toBe('Error performing saveNoteCache');
+      expect(result.returnMessage.messageType).toBe('warning');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should handle 429 rate limit error in createCallLog', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockRejectedValue({
+          response: { status: 429 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log');
+
+      const incomingData = {
+        logInfo: {
+          sessionId: 'session-rate-limit',
+          telephonySessionId: 'tel-session',
+          direction: 'Outbound',
+          from: { phoneNumber: '+1234567890' },
+          to: { phoneNumber: '+0987654321' }
+        },
+        contactId: 'contact-123',
+        note: 'Test'
+      };
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.returnMessage.messageType).toBe('warning');
+    });
+
+    test('should handle 401 authorization error in createCallLog', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockRejectedValue({
+          response: { status: 401 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log');
+
+      const incomingData = {
+        logInfo: {
+          sessionId: 'session-auth-error',
+          telephonySessionId: 'tel-session',
+          direction: 'Outbound',
+          from: { phoneNumber: '+1234567890' },
+          to: { phoneNumber: '+0987654321' }
+        },
+        contactId: 'contact-123',
+        note: 'Test'
+      };
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(false);
+      expect(result.extraDataTracking.statusCode).toBe(401);
+    });
+  });
+});
+