@app-connect/core 1.7.35 → 1.7.37

package/test/connector/mock.test.js

@@ -0,0 +1,131 @@
+jest.mock('shortid', () => ({
+  generate: jest.fn(() => 'mock-log-id'),
+}));
+
+const mockConnector = require('../../connector/mock');
+const { UserModel } = require('../../models/userModel');
+const { CallLogModel } = require('../../models/callLogModel');
+
+describe('mock connector', () => {
+  beforeEach(async () => {
+    await CallLogModel.destroy({ where: {} });
+    await UserModel.destroy({ where: {} });
+  });
+
+  test('creates and deletes the mock user idempotently', async () => {
+    const firstUser = await mockConnector.createUser();
+    const secondUser = await mockConnector.createUser();
+
+    expect(firstUser.id).toBe('mockUser');
+    expect(secondUser.id).toBe('mockUser');
+    await expect(UserModel.count({ where: { id: 'mockUser' } })).resolves.toBe(1);
+
+    await expect(mockConnector.deleteUser()).resolves.toBe(true);
+    await expect(mockConnector.deleteUser()).resolves.toBe(false);
+    await expect(UserModel.findByPk('mockUser')).resolves.toBeNull();
+  });
+
+  test('creates a mock call log only once for the same session identity', async () => {
+    await mockConnector.createCallLog({
+      sessionId: 'session-1',
+      extensionNumber: 101,
+      hashedExtensionId: 'hash-101',
+    });
+    await mockConnector.createCallLog({
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'hash-101',
+    });
+
+    const records = await CallLogModel.findAll({
+      where: {
+        sessionId: 'session-1',
+      },
+    });
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({
+      id: 'mock-log-id',
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'hash-101',
+      userId: 'mockUser',
+    });
+  });
+
+  test('returns matched and unmatched call logs in requested session order', async () => {
+    await mockConnector.createCallLog({
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'hash-101',
+    });
+    await mockConnector.createCallLog({
+      sessionId: 'session-3',
+      extensionNumber: '101',
+      hashedExtensionId: 'hash-101',
+    });
+
+    await expect(mockConnector.getCallLog({
+      sessionIds: 'session-1,session-2,session-3',
+      extensionNumber: '101',
+      hashedExtensionId: 'hash-101',
+    })).resolves.toEqual([
+      { sessionId: 'session-1', matched: true, logId: 'mockThirdPartyLogId' },
+      { sessionId: 'session-2', matched: false },
+      { sessionId: 'session-3', matched: true, logId: 'mockThirdPartyLogId' },
+    ]);
+  });
+
+  test('falls back to legacy extension matching when hashed extension id does not match', async () => {
+    await CallLogModel.create({
+      id: 'legacy-log-id',
+      sessionId: 'session-legacy',
+      extensionNumber: '101',
+      hashedExtensionId: '',
+      userId: 'mockUser',
+    });
+
+    await expect(mockConnector.getCallLog({
+      sessionIds: 'session-legacy',
+      extensionNumber: '101',
+      hashedExtensionId: 'new-hash-101',
+    })).resolves.toEqual([
+      { sessionId: 'session-legacy', matched: true, logId: 'mockThirdPartyLogId' },
+    ]);
+  });
+
+  test('cleanUpMockLogs removes only mock user call logs', async () => {
+    await CallLogModel.bulkCreate([
+      {
+        id: 'mock-log',
+        sessionId: 'mock-session',
+        extensionNumber: '',
+        hashedExtensionId: '',
+        userId: 'mockUser',
+      },
+      {
+        id: 'real-log',
+        sessionId: 'real-session',
+        extensionNumber: '',
+        hashedExtensionId: '',
+        userId: 'realUser',
+      },
+    ]);
+
+    await mockConnector.cleanUpMockLogs();
+
+    await expect(CallLogModel.findOne({
+      where: {
+        userId: 'mockUser',
+      },
+    })).resolves.toBeNull();
+    const realLog = await CallLogModel.findOne({
+      where: {
+        userId: 'realUser',
+      },
+    });
+    expect(realLog).toMatchObject({
+      id: 'real-log',
+      sessionId: 'real-session',
+    });
+  });
+});

package/test/connector/proxy/engine.test.js

@@ -8,6 +8,7 @@ const {
   renderDeep,
   joinUrl,
   performRequest,
+  mapFindContactResponse,
 } = require('../../../connector/proxy/engine');
 
 describe('proxy engine utilities', () => {
@@ -121,6 +122,90 @@ describe('proxy engine utilities', () => {
     const args = axios.mock.calls[0][0];
     expect(args.headers.Authorization).toBe(`Basic ${Buffer.from('login-key').toString('base64')}`);
   });
+
+  test('mapFindContactResponse maps contact created date', () => {
+    const config = {
+      operations: {
+        findContact: {
+          responseMapping: {
+            listPath: 'body.contacts',
+            item: {
+              idPath: 'id',
+              namePath: 'name',
+              createdDatePath: 'created_at',
+              mostRecentActivityDatePath: 'updated_at'
+            }
+          }
+        }
+      }
+    };
+    const response = {
+      data: {
+        contacts: [
+          {
+            id: 'c1',
+            name: 'Alice',
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-02-01T00:00:00Z'
+          }
+        ]
+      }
+    };
+
+    expect(mapFindContactResponse({ config, response })).toEqual([
+      expect.objectContaining({
+        id: 'c1',
+        name: 'Alice',
+        createdDate: '2024-01-01T00:00:00Z',
+        mostRecentActivityDate: '2024-02-01T00:00:00Z'
+      })
+    ]);
+  });
+
+  test('mapFindContactResponse can map findContactWithName responses', () => {
+    const config = {
+      operations: {
+        findContact: {
+          responseMapping: {
+            listPath: 'body.phoneMatches',
+            item: {
+              idPath: 'id',
+              namePath: 'name'
+            }
+          }
+        },
+        findContactWithName: {
+          responseMapping: {
+            listPath: 'body.nameMatches',
+            item: {
+              idPath: 'personId',
+              namePath: 'displayName',
+              createdDatePath: 'created'
+            }
+          }
+        }
+      }
+    };
+    const response = {
+      data: {
+        nameMatches: [
+          {
+            personId: 'p1',
+            displayName: 'Jane Smith',
+            created: '2023-05-01T00:00:00Z'
+          }
+        ]
+      }
+    };
+
+    expect(mapFindContactResponse({ config, response, opName: 'findContactWithName' })).toEqual([
+      expect.objectContaining({
+        id: 'p1',
+        name: 'Jane Smith',
+        createdDate: '2023-05-01T00:00:00Z'
+      })
+    ]);
+  });
 });
 
 

package/test/connector/proxy/index.test.js

@@ -126,6 +126,86 @@ describe('proxy connector - more coverage', () => {
     expect(token).toBe(Buffer.from('abc:').toString('base64'));
   });
 
+  test('getOauthInfo maps configured OAuth settings and falls back when config loading fails', async () => {
+    const oauthConfig = {
+      auth: {
+        type: 'oauth',
+        clientId: 'client-id',
+        clientSecret: 'client-secret',
+        tokenUrl: 'https://auth.example.com/token',
+        redirectUri: 'https://app.example.com/callback'
+      },
+      operations: {}
+    };
+
+    await expect(proxy.getOauthInfo({
+      proxyConfig: oauthConfig,
+      tokenUrl: 'https://override.example.com/token'
+    })).resolves.toEqual({
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      accessTokenUri: 'https://override.example.com/token',
+      redirectUri: 'https://app.example.com/callback'
+    });
+
+    Connector.getProxyConfig.mockRejectedValueOnce(new Error('config unavailable'));
+    await expect(proxy.getOauthInfo({ proxyId: 'missing-config' })).resolves.toEqual({});
+    await expect(proxy.getAuthType({ proxyId: '' })).resolves.toBe('apiKey');
+  });
+
+  test('getUserInfo returns a warning when the proxy config has no getUserInfo operation', async () => {
+    await expect(proxy.getUserInfo({
+      proxyConfig: { operations: {} },
+      platform: 'minimal'
+    })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        messageType: 'warning',
+        message: 'Could not load user information. The platform does not support getUserInfo operation.'
+      }
+    });
+  });
+
+  test('getUserList maps configured list responses and returns empty when unsupported', async () => {
+    const userListConfig = {
+      requestDefaults: { baseUrl: 'https://api.example.com' },
+      operations: {
+        getUserList: {
+          method: 'GET',
+          url: '/users',
+          responseMapping: {
+            listPath: 'body.records',
+            idPath: 'user.id',
+            namePath: 'profile.name',
+            emailPath: 'email'
+          }
+        }
+      }
+    };
+    axios.mockResolvedValueOnce({
+      data: {
+        records: [
+          { user: { id: 'u1' }, profile: { name: 'Ada' }, email: 'ada@example.com' },
+          { user: { id: 'u2' }, profile: { name: 'Grace' }, email: 'grace@example.com' }
+        ]
+      }
+    });
+
+    await expect(proxy.getUserList({
+      user: { platformAdditionalInfo: { proxyId: 'p1' } },
+      authHeader: 'Bearer token',
+      proxyConfig: userListConfig
+    })).resolves.toEqual([
+      { id: 'u1', name: 'Ada', email: 'ada@example.com' },
+      { id: 'u2', name: 'Grace', email: 'grace@example.com' }
+    ]);
+
+    await expect(proxy.getUserList({
+      user: { platformAdditionalInfo: { proxyId: 'p1' } },
+      proxyConfig: { operations: {} }
+    })).resolves.toEqual([]);
+  });
+
   test('getUserInfo maps id/name/message/platformAdditionalInfo', async () => {
     const cfg = JSON.parse(JSON.stringify(sampleConfig));
     delete cfg.auth; // ensure provided authHeader is used
@@ -165,6 +245,37 @@ describe('proxy connector - more coverage', () => {
     expect(out.matchedContactInfo[0].id).toBe('c1');
   });
 
+  test('contact operations return supported empty responses when omitted from manifest', async () => {
+    const proxyConfig = { operations: {} };
+    const user = { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } };
+
+    await expect(proxy.findContact({
+      user,
+      authHeader: 'x',
+      phoneNumber: '+1',
+      proxyConfig
+    })).resolves.toEqual({ successful: true, matchedContactInfo: [] });
+
+    await expect(proxy.findContactWithName({
+      user,
+      authHeader: 'x',
+      name: 'Ada',
+      proxyConfig
+    })).resolves.toEqual({ successful: true, matchedContactInfo: [] });
+
+    await expect(proxy.createContact({
+      user,
+      authHeader: 'x',
+      phoneNumber: '+1',
+      newContactName: 'Ada',
+      newContactType: 'Contact',
+      proxyConfig
+    })).resolves.toEqual({
+      contactInfo: null,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+  });
+
   test('createContact maps object response', async () => {
     Connector.getProxyConfig.mockResolvedValue(sampleConfig);
     axios.mockResolvedValue({ data: { id: 'c2', name: 'Bob', type: 'Lead' } });
@@ -182,6 +293,70 @@ describe('proxy connector - more coverage', () => {
     expect(res.returnMessage.messageType).toBe('success');
   });
 
+  test('call and message log operations return Not supported when omitted from manifest', async () => {
+    const proxyConfig = { operations: {} };
+    const user = { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } };
+    const commonCall = {
+      user,
+      contactInfo: { id: 'c1', name: 'Ada' },
+      authHeader: 'x',
+      proxyConfig
+    };
+
+    await expect(proxy.createCallLog({
+      ...commonCall,
+      callLog: { direction: 'Inbound', startTime: Date.now(), duration: 30 },
+      note: ''
+    })).resolves.toEqual({
+      logId: undefined,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.getCallLog({
+      user,
+      callLogId: 'L1',
+      contactId: 'c1',
+      authHeader: 'x',
+      proxyConfig
+    })).resolves.toEqual({
+      callLogInfo: null,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.updateCallLog({
+      user,
+      existingCallLog: { thirdPartyLogId: 'L1' },
+      authHeader: 'x',
+      startTime: Date.now(),
+      duration: 30,
+      proxyConfig
+    })).resolves.toEqual({
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.createMessageLog({
+      user,
+      contactInfo: { id: 'c1', name: 'Ada' },
+      authHeader: 'x',
+      message: { creationTime: Date.now() },
+      proxyConfig
+    })).resolves.toEqual({
+      logId: undefined,
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+
+    await expect(proxy.updateMessageLog({
+      user,
+      contactInfo: { id: 'c1', name: 'Ada' },
+      existingMessageLog: { thirdPartyLogId: 'M1' },
+      message: { creationTime: Date.now() },
+      authHeader: 'x',
+      proxyConfig
+    })).resolves.toEqual({
+      returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 }
+    });
+  });
+
   test('createMessageLog maps idPath and updateMessageLog returns success', async () => {
     Connector.getProxyConfig.mockResolvedValue(sampleConfig);
     axios.mockResolvedValueOnce({ data: { activity: { id: 'M1' } } });
@@ -227,6 +402,40 @@ describe('proxy connector - more coverage', () => {
     expect(res.returnMessage.message).toMatch(/Not supported/);
   });
 
+  test('upsertCallDisposition performs configured operation when supported', async () => {
+    const dispositionConfig = {
+      requestDefaults: { baseUrl: 'https://api.example.com' },
+      operations: {
+        upsertCallDisposition: {
+          method: 'POST',
+          url: '/activities/{{thirdPartyLogId}}/disposition',
+          body: {
+            result: '{{dispositions.0.value}}'
+          }
+        }
+      }
+    };
+    Connector.getProxyConfig.mockResolvedValue(dispositionConfig);
+    axios.mockResolvedValueOnce({ data: { ok: true } });
+
+    const res = await proxy.upsertCallDisposition({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      existingCallLog: { thirdPartyLogId: 'L1' },
+      authHeader: 'x',
+      dispositions: [{ value: 'Connected' }]
+    });
+
+    expect(res).toEqual({
+      logId: 'L1',
+      returnMessage: { message: 'Disposition updated', messageType: 'success', ttl: 2000 }
+    });
+    expect(axios.mock.calls[0][0]).toMatchObject({
+      method: 'POST',
+      url: 'https://api.example.com/activities/L1/disposition',
+      data: { result: 'Connected' }
+    });
+  });
+
   test('getLicenseStatus maps values with custom config', async () => {
     const licenseConfig = {
       requestDefaults: { baseUrl: 'https://api.example.com' },
@@ -252,6 +461,23 @@ describe('proxy connector - more coverage', () => {
     expect(s.licenseStatusDescription).toBe('All good');
   });
 
+  test('getLicenseStatus handles missing users and missing license operations', async () => {
+    UserModel.findByPk.mockResolvedValueOnce(null);
+    await expect(proxy.getLicenseStatus({ userId: 'missing', platform: 'x' })).resolves.toEqual({
+      isLicenseValid: false,
+      licenseStatus: 'Invalid (User not found)',
+      licenseStatusDescription: ''
+    });
+
+    UserModel.findByPk.mockResolvedValueOnce({ id: 'u1', accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } });
+    Connector.getProxyConfig.mockResolvedValueOnce({ operations: {} });
+    await expect(proxy.getLicenseStatus({ userId: 'u1', platform: 'x' })).resolves.toEqual({
+      isLicenseValid: true,
+      licenseStatus: 'Basic',
+      licenseStatusDescription: ''
+    });
+  });
+
   test('unAuthorize without custom op clears tokens and saves user', async () => {
     Connector.getProxyConfig.mockResolvedValue(sampleConfig); // no unAuthorize op
     const user = { accessToken: 't', refreshToken: 'r', save: jest.fn(), platformAdditionalInfo: { proxyId: 'p1' } };
@@ -275,5 +501,25 @@ describe('proxy connector - more coverage', () => {
     expect(out.returnMessage.message).toMatch(/Logged out/);
     expect(user.accessToken).toBe('');
   });
+
+  test('unAuthorize returns a database warning when saving cleared tokens fails', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig);
+    const user = {
+      accessToken: 't',
+      refreshToken: 'r',
+      save: jest.fn().mockRejectedValue(new Error('save failed')),
+      platformAdditionalInfo: { proxyId: 'p1' }
+    };
+
+    await expect(proxy.unAuthorize({ user })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        message: 'Database operation failed',
+        messageType: 'warning'
+      }
+    });
+    expect(user.accessToken).toBe('');
+    expect(user.refreshToken).toBe('');
+  });
 });
 

package/test/connector/proxy/sample.json

@@ -47,6 +47,7 @@
           "namePath": "name",
           "typePath": "",
           "phonePath": "",
+          "createdDatePath": "",
           "additionalInfoPath": ""
         }
       }