@app-connect/core 1.7.36 → 1.7.38

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

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

package/test/models/accountDataModel.test.js

@@ -1,98 +0,0 @@
-// 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,
-    }),
-  };
-});
-
-const { AccountDataModel, getOrRefreshAccountData } = require('../../models/accountDataModel');
-const { sequelize } = require('../../models/sequelize');
-
-describe('getOrRefreshAccountData', () => {
-  beforeAll(async () => {
-    await AccountDataModel.sync({ force: true });
-  });
-
-  afterEach(async () => {
-    await AccountDataModel.destroy({ where: {} });
-  });
-
-  afterAll(async () => {
-    await sequelize.close();
-  });
-
-  test('returns cached data when record exists and refresh not forced', async () => {
-    await AccountDataModel.create({
-      rcAccountId: 'acc-1',
-      platformName: 'test-platform',
-      dataKey: 'key-1',
-      data: { cached: true },
-    });
-
-    const fetchFn = jest.fn().mockResolvedValue({ cached: false });
-
-    const out = await getOrRefreshAccountData({
-      rcAccountId: 'acc-1',
-      platformName: 'test-platform',
-      dataKey: 'key-1',
-      forceRefresh: false,
-      fetchFn,
-    });
-
-    expect(out).toEqual({ cached: true });
-    expect(fetchFn).not.toHaveBeenCalled();
-  });
-
-  test('creates new record when none exists', async () => {
-    const fetchFn = jest.fn().mockResolvedValue({ fresh: 'data' });
-
-    const out = await getOrRefreshAccountData({
-      rcAccountId: 'acc-2',
-      platformName: 'test-platform',
-      dataKey: 'key-2',
-      fetchFn,
-    });
-
-    expect(out).toEqual({ fresh: 'data' });
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-
-    const stored = await AccountDataModel.findOne({
-      where: { rcAccountId: 'acc-2', platformName: 'test-platform', dataKey: 'key-2' },
-    });
-    expect(stored).not.toBeNull();
-    expect(stored.data).toEqual({ fresh: 'data' });
-  });
-
-  test('refreshes existing record when forceRefresh is true', async () => {
-    await AccountDataModel.create({
-      rcAccountId: 'acc-3',
-      platformName: 'test-platform',
-      dataKey: 'key-3',
-      data: { cached: true },
-    });
-
-    const fetchFn = jest.fn().mockResolvedValue({ cached: false, updated: true });
-
-    const out = await getOrRefreshAccountData({
-      rcAccountId: 'acc-3',
-      platformName: 'test-platform',
-      dataKey: 'key-3',
-      forceRefresh: true,
-      fetchFn,
-    });
-
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-    expect(out).toEqual({ cached: false, updated: true });
-
-    const refreshed = await AccountDataModel.findOne({
-      where: { rcAccountId: 'acc-3', platformName: 'test-platform', dataKey: 'key-3' },
-    });
-    expect(refreshed.data).toEqual({ cached: false, updated: true });
-  });
-});
-

package/test/models/callDownListModel.test.js

@@ -1,125 +0,0 @@
-const { CallDownListModel } = require('../../models/callDownListModel');
-
-describe('CallDownListModel', () => {
-  beforeAll(async () => {
-    await CallDownListModel.sync({ force: true });
-  });
-
-  afterEach(async () => {
-    await CallDownListModel.destroy({ where: {} });
-  });
-
-  test('defines the expected fields and indexes', () => {
-    const attributes = CallDownListModel.rawAttributes;
-
-    expect(attributes.id.primaryKey).toBe(true);
-    expect(attributes.userId.type.key).toBe('STRING');
-    expect(attributes.contactId.type.key).toBe('STRING');
-    expect(attributes.contactType.type.key).toBe('STRING');
-    expect(attributes.status.type.key).toBe('STRING');
-    expect(attributes.scheduledAt.type.key).toBe('DATE');
-    expect(attributes.lastCallAt.type.key).toBe('DATE');
-    expect(CallDownListModel.options.timestamps).toBe(true);
-    expect(CallDownListModel.options.indexes).toEqual(expect.arrayContaining([
-      expect.objectContaining({ fields: ['userId'] }),
-      expect.objectContaining({ fields: ['status'] }),
-      expect.objectContaining({ fields: ['scheduledAt'] }),
-      expect.objectContaining({ fields: ['userId', 'status'] }),
-    ]));
-  });
-
-  test('creates and reads a scheduled callback record', async () => {
-    const scheduledAt = new Date('2026-07-02T10:00:00.000Z');
-
-    await CallDownListModel.create({
-      id: 'call-down-1',
-      userId: 'user-1',
-      contactId: 'contact-1',
-      contactType: 'Lead',
-      status: 'Pending',
-      scheduledAt,
-    });
-
-    const record = await CallDownListModel.findByPk('call-down-1');
-
-    expect(record).toMatchObject({
-      id: 'call-down-1',
-      userId: 'user-1',
-      contactId: 'contact-1',
-      contactType: 'Lead',
-      status: 'Pending',
-    });
-    expect(record.scheduledAt.toISOString()).toBe('2026-07-02T10:00:00.000Z');
-    expect(record.lastCallAt).toBeNull();
-  });
-
-  test('allows nullable fields under the current schema', async () => {
-    await CallDownListModel.create({
-      id: 'minimal-call-down',
-    });
-
-    const record = await CallDownListModel.findByPk('minimal-call-down');
-
-    expect(record.userId).toBeNull();
-    expect(record.contactId).toBeNull();
-    expect(record.status).toBeNull();
-    expect(record.scheduledAt).toBeNull();
-    expect(record.lastCallAt).toBeNull();
-  });
-
-  test('updates callback status and last call time', async () => {
-    await CallDownListModel.create({
-      id: 'call-down-update',
-      userId: 'user-1',
-      contactId: 'contact-1',
-      contactType: 'Contact',
-      status: 'Pending',
-      scheduledAt: new Date('2026-07-02T10:00:00.000Z'),
-    });
-
-    const lastCallAt = new Date('2026-07-02T10:30:00.000Z');
-    await CallDownListModel.update({
-      status: 'Called',
-      lastCallAt,
-    }, {
-      where: { id: 'call-down-update' },
-    });
-
-    const record = await CallDownListModel.findByPk('call-down-update');
-    expect(record.status).toBe('Called');
-    expect(record.lastCallAt.toISOString()).toBe('2026-07-02T10:30:00.000Z');
-  });
-
-  test('queries by user and status together', async () => {
-    await CallDownListModel.bulkCreate([
-      {
-        id: 'call-down-user-1-pending',
-        userId: 'user-1',
-        status: 'Pending',
-        scheduledAt: new Date('2026-07-02T10:00:00.000Z'),
-      },
-      {
-        id: 'call-down-user-1-called',
-        userId: 'user-1',
-        status: 'Called',
-        scheduledAt: new Date('2026-07-02T11:00:00.000Z'),
-      },
-      {
-        id: 'call-down-user-2-pending',
-        userId: 'user-2',
-        status: 'Pending',
-        scheduledAt: new Date('2026-07-02T12:00:00.000Z'),
-      },
-    ]);
-
-    const records = await CallDownListModel.findAll({
-      where: {
-        userId: 'user-1',
-        status: 'Pending',
-      },
-    });
-
-    expect(records).toHaveLength(1);
-    expect(records[0].id).toBe('call-down-user-1-pending');
-  });
-});