@app-connect/core 1.7.35 → 1.7.36

package/test/models/models.test.js

@@ -16,6 +16,10 @@ const { UserModel } = require('../../models/userModel');
 const { CacheModel } = require('../../models/cacheModel');
 const { AdminConfigModel } = require('../../models/adminConfigModel');
 const { sequelize } = require('../../models/sequelize');
+const {
+  ensureCallLogsHashedExtensionIdSchema,
+  sqliteCallLogsPkIncludesHashedExtension,
+} = require('../../lib/migrateCallLogsSchema');
 
 describe('Core Models', () => {
   beforeAll(async () => {
@@ -208,6 +212,94 @@ describe('Core Models', () => {
       expect(logs).toHaveLength(2);
     });
 
+    test('should use hashedExtensionId as part of call log primary key', async () => {
+      // Arrange & Act
+      await CallLogModel.create({
+        id: 'call-shared-hash',
+        sessionId: 'session-shared-hash',
+        extensionNumber: '',
+        hashedExtensionId: 'hashed-1',
+        platform: 'testCRM',
+        thirdPartyLogId: 'third-party-hash-1',
+        userId: 'user-1'
+      });
+      await CallLogModel.create({
+        id: 'call-shared-hash',
+        sessionId: 'session-shared-hash',
+        extensionNumber: '',
+        hashedExtensionId: 'hashed-2',
+        platform: 'testCRM',
+        thirdPartyLogId: 'third-party-hash-2',
+        userId: 'user-1'
+      });
+
+      // Assert
+      const logs = await CallLogModel.findAll({
+        where: {
+          id: 'call-shared-hash',
+          sessionId: 'session-shared-hash'
+        }
+      });
+      expect(logs).toHaveLength(2);
+    });
+
+    test('should migrate legacy call log schema to hashed extension identity key', async () => {
+      await CallLogModel.drop();
+      await sequelize.query(`
+        CREATE TABLE callLogs (
+          id VARCHAR(255) NOT NULL,
+          sessionId VARCHAR(255) NOT NULL,
+          extensionNumber VARCHAR(255) NOT NULL DEFAULT '',
+          platform VARCHAR(255),
+          thirdPartyLogId VARCHAR(255),
+          userId VARCHAR(255),
+          contactId VARCHAR(255),
+          createdAt DATETIME NOT NULL,
+          updatedAt DATETIME NOT NULL,
+          PRIMARY KEY (id, sessionId, extensionNumber)
+        );
+      `);
+      await sequelize.query(`
+        INSERT INTO callLogs (
+          id,
+          sessionId,
+          extensionNumber,
+          platform,
+          thirdPartyLogId,
+          userId,
+          contactId,
+          createdAt,
+          updatedAt
+        ) VALUES (
+          'legacy-call',
+          'legacy-session',
+          '101',
+          'testCRM',
+          'third-party-legacy',
+          'user-1',
+          'contact-1',
+          '2026-01-01T00:00:00.000Z',
+          '2026-01-01T00:00:00.000Z'
+        );
+      `);
+
+      await ensureCallLogsHashedExtensionIdSchema(sequelize);
+
+      const tableDescription = await sequelize.getQueryInterface().describeTable('callLogs');
+      expect(tableDescription.hashedExtensionId).toBeDefined();
+      await expect(sqliteCallLogsPkIncludesHashedExtension(sequelize)).resolves.toBe(true);
+      const migratedLog = await CallLogModel.findOne({
+        where: {
+          id: 'legacy-call',
+          sessionId: 'legacy-session',
+          extensionNumber: '101',
+          hashedExtensionId: ''
+        }
+      });
+      expect(migratedLog).not.toBeNull();
+      expect(migratedLog.thirdPartyLogId).toBe('third-party-legacy');
+    });
+
     test('should find call logs by session ID', async () => {
       // Arrange
       await CallLogModel.create({

package/test/routes/calldownRoutes.test.js

@@ -0,0 +1,224 @@
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('../../handlers/calldown', () => ({
+  schedule: jest.fn(),
+  list: jest.fn(),
+  remove: jest.fn(),
+  update: jest.fn(),
+}));
+jest.mock('../../lib/analytics', () => ({
+  init: jest.fn(),
+  track: jest.fn(),
+}));
+jest.mock('../../lib/jwt', () => ({
+  decodeJwt: jest.fn(),
+  generateJwt: jest.fn().mockReturnValue('refreshed-crm-jwt'),
+}));
+
+const calldown = require('../../handlers/calldown');
+const analytics = require('../../lib/analytics');
+const jwt = require('../../lib/jwt');
+const { createCoreRouter } = require('../../index');
+
+describe('Calldown Routes', () => {
+  let app;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jwt.decodeJwt.mockReturnValue({
+      id: 'crm-user-id',
+      platform: 'testCRM',
+    });
+    app = express();
+    app.use(express.json());
+    app.use('/', createCoreRouter());
+  });
+
+  test('POST /calldown schedules a callback and delegates body/token values', async () => {
+    calldown.schedule.mockResolvedValue({
+      id: 'call-down-id',
+    });
+
+    const response = await request(app)
+      .post('/calldown')
+      .query({
+        jwtToken: 'crm-jwt',
+        rcAccessToken: 'rc-token',
+      })
+      .send({
+        contactId: 'contact-1',
+        scheduledAt: '2026-07-02T13:00:00.000Z',
+      });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      successful: true,
+      id: 'call-down-id',
+    });
+    expect(calldown.schedule).toHaveBeenCalledWith({
+      jwtToken: 'crm-jwt',
+      rcAccessToken: 'rc-token',
+      body: {
+        contactId: 'contact-1',
+        scheduledAt: '2026-07-02T13:00:00.000Z',
+      },
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Schedule call down',
+      interfaceName: 'scheduleCallDown',
+      success: true,
+    }));
+  });
+
+  test('POST /calldown rejects missing CRM auth token', async () => {
+    const response = await request(app)
+      .post('/calldown')
+      .send({ contactId: 'contact-1' });
+
+    expect(response.status).toBe(400);
+    expect(response.text).toBe('Please go to Settings and authorize CRM platform');
+    expect(calldown.schedule).not.toHaveBeenCalled();
+  });
+
+  test('GET /calldown returns items from handler with status filter', async () => {
+    calldown.list.mockResolvedValue({
+      items: [
+        {
+          id: 'call-down-id',
+          status: 'called',
+        },
+      ],
+    });
+
+    const response = await request(app)
+      .get('/calldown')
+      .query({
+        jwtToken: 'crm-jwt',
+        status: 'called',
+      });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      successful: true,
+      items: [
+        {
+          id: 'call-down-id',
+          status: 'called',
+        },
+      ],
+    });
+    expect(calldown.list).toHaveBeenCalledWith({
+      jwtToken: 'crm-jwt',
+      status: 'called',
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Get call down list',
+      interfaceName: 'getCallDownList',
+      success: true,
+    }));
+  });
+
+  test('GET /calldown maps handler errors to a 400 error body', async () => {
+    calldown.list.mockRejectedValue(new Error('Unauthorized'));
+
+    const response = await request(app)
+      .get('/calldown')
+      .query({ jwtToken: 'crm-jwt' });
+
+    expect(response.status).toBe(400);
+    expect(response.body).toEqual({
+      error: 'Unauthorized',
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Get call down list',
+      success: false,
+    }));
+  });
+
+  test('DELETE /calldown/:id delegates deletion by route parameter', async () => {
+    calldown.remove.mockResolvedValue({
+      successful: true,
+    });
+
+    const response = await request(app)
+      .delete('/calldown/call-down-id')
+      .query({ jwtToken: 'crm-jwt' });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      successful: true,
+    });
+    expect(calldown.remove).toHaveBeenCalledWith({
+      jwtToken: 'crm-jwt',
+      id: 'call-down-id',
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Delete call down item',
+      interfaceName: 'deleteCallDownItem',
+      success: true,
+    }));
+  });
+
+  test('DELETE /calldown/:id rejects missing CRM auth token', async () => {
+    const response = await request(app)
+      .delete('/calldown/call-down-id');
+
+    expect(response.status).toBe(400);
+    expect(response.text).toBe('Please go to Settings and authorize CRM platform');
+    expect(calldown.remove).not.toHaveBeenCalled();
+  });
+
+  test('PATCH /calldown/:id delegates allowed update body', async () => {
+    calldown.update.mockResolvedValue({
+      successful: true,
+    });
+
+    const response = await request(app)
+      .patch('/calldown/call-down-id')
+      .query({ jwtToken: 'crm-jwt' })
+      .send({
+        status: 'called',
+        lastCallAt: '2026-07-02T14:00:00.000Z',
+      });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      successful: true,
+    });
+    expect(calldown.update).toHaveBeenCalledWith({
+      jwtToken: 'crm-jwt',
+      id: 'call-down-id',
+      updateData: {
+        status: 'called',
+        lastCallAt: '2026-07-02T14:00:00.000Z',
+      },
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Mark call down called',
+      interfaceName: 'markCallDownCalled',
+      success: true,
+    }));
+  });
+
+  test('PATCH /calldown/:id maps handler errors to a 400 error body', async () => {
+    calldown.update.mockRejectedValue(new Error('No valid fields to update'));
+
+    const response = await request(app)
+      .patch('/calldown/call-down-id')
+      .query({ jwtToken: 'crm-jwt' })
+      .send({
+        unexpectedField: 'ignored',
+      });
+
+    expect(response.status).toBe(400);
+    expect(response.body).toEqual({
+      error: 'No valid fields to update',
+    });
+    expect(analytics.track).toHaveBeenCalledWith(expect.objectContaining({
+      eventName: 'Mark call down called',
+      success: false,
+    }));
+  });
+});
+