@app-connect/core 1.7.35 → 1.7.36

package/lib/migrateCallLogsSchema.js

@@ -1,5 +1,9 @@
 const Sequelize = require('sequelize');
 
+const CALL_LOGS_TABLE = 'callLogs';
+const HASHED_EXTENSION_ID_COLUMN = 'hashedExtensionId';
+const CALL_LOG_IDENTITY_PK_COLUMNS = ['id', 'sessionId', 'extensionNumber', HASHED_EXTENSION_ID_COLUMN];
+
 function findColumnKey(tableDescription, name) {
     const lower = name.toLowerCase();
     return Object.keys(tableDescription).find((k) => k.toLowerCase() === lower);
@@ -13,35 +17,51 @@ async function fetchCallLogsCreateSqlSqlite(sequelize, options = {}) {
     return rows[0]?.sql ?? null;
 }
 
-function callLogsCreateSqlClaimsExtensionPk(createSql) {
+function callLogsCreateSqlClaimsPkColumns(createSql, columns) {
     if (!createSql || typeof createSql !== 'string') {
         return false;
     }
     const pkRegex = /PRIMARY\s+KEY\s*\(([^)]+)\)/gi;
     let m;
     while ((m = pkRegex.exec(createSql)) !== null) {
-        if (/\bextensionNumber\b/i.test(m[1])) {
+        const pkColumns = m[1]
+            .split(',')
+            .map((column) => column.replace(/["'`\[\]\s]/g, '').toLowerCase());
+        if (columns.every((column) => pkColumns.includes(column.toLowerCase()))) {
             return true;
         }
     }
     return false;
 }
 
+function callLogsCreateSqlClaimsExtensionPk(createSql) {
+    return callLogsCreateSqlClaimsPkColumns(createSql, ['extensionNumber']);
+}
+
 async function sqliteCallLogsPkIncludesExtension(sequelize, options = {}) {
     const sql = await fetchCallLogsCreateSqlSqlite(sequelize, options);
     return callLogsCreateSqlClaimsExtensionPk(sql);
 }
 
+async function sqliteCallLogsPkIncludesHashedExtension(sequelize, options = {}) {
+    const sql = await fetchCallLogsCreateSqlSqlite(sequelize, options);
+    return callLogsCreateSqlClaimsPkColumns(sql, CALL_LOG_IDENTITY_PK_COLUMNS);
+}
+
+async function describeCallLogsTable(sequelize, options = {}) {
+    return sequelize.getQueryInterface().describeTable(CALL_LOGS_TABLE, options);
+}
+
 /**
  * SQLite cannot change composite PK via Sequelize addConstraint (it appends a second PRIMARY KEY).
- * Rebuild the table with the correct 3-column primary key and copy rows.
+ * Rebuild the table with the current call-log identity primary key and copy rows.
  */
-async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
+async function migrateCallLogsIdentitySqlite(sequelize, transaction) {
     const qg = sequelize.getQueryInterface().queryGenerator;
     const qi = sequelize.getQueryInterface();
     const q = (id) => qg.quoteIdentifier(id);
     const tmpName = `callLogs_mig_legacy_${Date.now()}`;
-    const mainTableSql = qg.quoteTable({ tableName: 'callLogs' });
+    const mainTableSql = qg.quoteTable({ tableName: CALL_LOGS_TABLE });
     const tmpTableSql = qg.quoteTable({ tableName: tmpName });
 
     await sequelize.query(
@@ -55,13 +75,14 @@ async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
       ${q('id')} VARCHAR(255) NOT NULL,
       ${q('sessionId')} VARCHAR(255) NOT NULL,
       ${q('extensionNumber')} VARCHAR(255) NOT NULL DEFAULT '',
+      ${q(HASHED_EXTENSION_ID_COLUMN)} VARCHAR(255) NOT NULL DEFAULT '',
       ${q('platform')} VARCHAR(255),
       ${q('thirdPartyLogId')} VARCHAR(255),
       ${q('userId')} VARCHAR(255),
       ${q('contactId')} VARCHAR(255),
       ${q('createdAt')} DATETIME NOT NULL,
       ${q('updatedAt')} DATETIME NOT NULL,
-      PRIMARY KEY (${q('id')}, ${q('sessionId')}, ${q('extensionNumber')})
+      PRIMARY KEY (${CALL_LOG_IDENTITY_PK_COLUMNS.map(q).join(', ')})
     );
     `,
         { transaction },
@@ -73,6 +94,7 @@ async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
         'id',
         'sessionId',
         'extensionNumber',
+        HASHED_EXTENSION_ID_COLUMN,
         'platform',
         'thirdPartyLogId',
         'userId',
@@ -82,7 +104,7 @@ async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
     ];
 
     const missingRequired = targetCols.filter(
-        (c) => findColumnKey(oldDesc, c) == null && c !== 'extensionNumber',
+        (c) => findColumnKey(oldDesc, c) == null && c !== 'extensionNumber' && c !== HASHED_EXTENSION_ID_COLUMN,
     );
     if (missingRequired.length) {
         throw new Error(
@@ -109,8 +131,107 @@ async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
     await sequelize.query(`DROP TABLE ${tmpTableSql};`, { transaction });
 }
 
+async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
+    return migrateCallLogsIdentitySqlite(sequelize, transaction);
+}
+
+async function getPostgresPrimaryKeyConstraint(sequelize, options = {}) {
+    const constraints = await sequelize.query(
+        `
+        SELECT tc.constraint_name AS "constraintName"
+        FROM information_schema.table_constraints tc
+        WHERE tc.table_name = :tableName
+          AND tc.constraint_type = 'PRIMARY KEY'
+        LIMIT 1
+        `,
+        {
+            type: Sequelize.QueryTypes.SELECT,
+            replacements: { tableName: CALL_LOGS_TABLE },
+            ...options,
+        },
+    );
+    return constraints[0]?.constraintName ?? null;
+}
+
+async function postgresCallLogsPkIncludesHashedExtension(sequelize, options = {}) {
+    const pkConstraintName = await getPostgresPrimaryKeyConstraint(sequelize, options);
+    if (!pkConstraintName) {
+        return false;
+    }
+    const rows = await sequelize.query(
+        `
+        SELECT kcu.column_name AS "columnName"
+        FROM information_schema.key_column_usage kcu
+        WHERE kcu.table_name = :tableName
+          AND kcu.constraint_name = :constraintName
+        ORDER BY kcu.ordinal_position
+        `,
+        {
+            type: Sequelize.QueryTypes.SELECT,
+            replacements: { tableName: CALL_LOGS_TABLE, constraintName: pkConstraintName },
+            ...options,
+        },
+    );
+    const pkColumns = rows.map((row) => row.columnName.toLowerCase());
+    return CALL_LOG_IDENTITY_PK_COLUMNS.every((column) => pkColumns.includes(column.toLowerCase()));
+}
+
+async function migrateCallLogsIdentityPostgres(sequelize, transaction) {
+    const qi = sequelize.getQueryInterface();
+    const qg = qi.queryGenerator;
+    const table = qg.quoteTable({ tableName: CALL_LOGS_TABLE });
+    const pkConstraintName = await getPostgresPrimaryKeyConstraint(sequelize, { transaction });
+    if (pkConstraintName) {
+        await sequelize.query(
+            `ALTER TABLE ${table} DROP CONSTRAINT ${qg.quoteIdentifier(pkConstraintName)};`,
+            { transaction },
+        );
+    }
+    await sequelize.query(
+        `ALTER TABLE ${table} ADD PRIMARY KEY (${CALL_LOG_IDENTITY_PK_COLUMNS.map((column) => qg.quoteIdentifier(column)).join(', ')});`,
+        { transaction },
+    );
+}
+
+async function ensureCallLogsHashedExtensionIdSchema(sequelize) {
+    const qi = sequelize.getQueryInterface();
+    const dialect = sequelize.getDialect();
+    let desc = await describeCallLogsTable(sequelize);
+
+    if (findColumnKey(desc, HASHED_EXTENSION_ID_COLUMN) == null) {
+        await qi.addColumn(CALL_LOGS_TABLE, HASHED_EXTENSION_ID_COLUMN, {
+            type: Sequelize.STRING,
+            allowNull: false,
+            defaultValue: '',
+        });
+        desc = await describeCallLogsTable(sequelize);
+    }
+
+    if (dialect === 'sqlite') {
+        const hasIdentityPk = await sqliteCallLogsPkIncludesHashedExtension(sequelize);
+        if (!hasIdentityPk) {
+            await sequelize.transaction(async (transaction) => {
+                await migrateCallLogsIdentitySqlite(sequelize, transaction);
+            });
+        }
+        return;
+    }
+
+    if (dialect === 'postgres') {
+        const hasIdentityPk = await postgresCallLogsPkIncludesHashedExtension(sequelize);
+        if (!hasIdentityPk) {
+            await sequelize.transaction(async (transaction) => {
+                await migrateCallLogsIdentityPostgres(sequelize, transaction);
+            });
+        }
+    }
+}
+
 module.exports = {
     findColumnKey,
     migrateCallLogsExtensionNumberSqlite,
+    migrateCallLogsIdentitySqlite,
     sqliteCallLogsPkIncludesExtension,
+    sqliteCallLogsPkIncludesHashedExtension,
+    ensureCallLogsHashedExtensionIdSchema,
 };

package/models/callLogModel.js

@@ -18,6 +18,12 @@ exports.CallLogModel = sequelize.define('callLogs', {
     allowNull: false,
     defaultValue: '',
   },
+  hashedExtensionId: {
+    type: Sequelize.STRING,
+    primaryKey: true,
+    allowNull: false,
+    defaultValue: '',
+  },
   platform: {
     type: Sequelize.STRING,
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.35",
+  "version": "1.7.36",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,4 +1,20 @@
 {
+    "1.7.36": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Custom fields for call pop parameters"
+            },
+            {
+                "type": "New",
+                "description": "New option for auto log multi match resolver - Earliest created"
+            },
+            {
+                "type": "Fix",
+                "description": "Server-side logging call log id inconsistency"
+            }
+        ]
+    },
     "1.7.35": {
         "global": [
             {

package/test/connector/developerPortal.test.js

@@ -0,0 +1,166 @@
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
+jest.mock('../../lib/logger', () => ({
+  logger: {
+    error: jest.fn(),
+  },
+}));
+
+const axios = require('axios');
+const { logger } = require('../../lib/logger');
+const {
+  getPublicConnectorList,
+  getConnectorManifest,
+} = require('../../connector/developerPortal');
+
+describe('developerPortal connector', () => {
+  beforeEach(() => {
+    axios.get.mockReset();
+    logger.error.mockReset();
+  });
+
+  test('loads the public connector list', async () => {
+    axios.get.mockResolvedValueOnce({
+      data: {
+        connectors: [
+          { id: 'public-a' },
+          { id: 'public-b' },
+        ],
+      },
+    });
+
+    await expect(getPublicConnectorList()).resolves.toEqual({
+      connectors: [
+        { id: 'public-a' },
+        { id: 'public-b' },
+      ],
+    });
+    expect(axios.get).toHaveBeenCalledWith('https://appconnect.labs.ringcentral.com/public-api/connectors');
+    expect(logger.error).not.toHaveBeenCalled();
+  });
+
+  test('returns null when public connector list loading fails', async () => {
+    const error = new Error('network down');
+    axios.get.mockRejectedValueOnce(error);
+
+    await expect(getPublicConnectorList()).resolves.toBeNull();
+
+    expect(logger.error).toHaveBeenCalledWith('Error getting public connector list:', error);
+  });
+
+  test('loads a public connector manifest by id', async () => {
+    axios.get.mockResolvedValueOnce({
+      data: {
+        id: 'salesforce',
+        name: 'Salesforce',
+      },
+    });
+
+    await expect(getConnectorManifest({
+      connectorId: 'salesforce',
+    })).resolves.toEqual({
+      id: 'salesforce',
+      name: 'Salesforce',
+    });
+    expect(axios.get).toHaveBeenCalledWith('https://appconnect.labs.ringcentral.com/public-api/connectors/salesforce/manifest');
+  });
+
+  test('loads a private connector manifest for the requesting account', async () => {
+    axios.get
+      .mockResolvedValueOnce({
+        data: {
+          privateConnectors: [
+            { id: 'private-crm' },
+          ],
+          sharedConnectors: [],
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          id: 'private-crm',
+          access: 'internal',
+        },
+      });
+
+    await expect(getConnectorManifest({
+      rcAccountId: 'rc-account-1',
+      connectorId: 'private-crm',
+      isPrivate: true,
+    })).resolves.toEqual({
+      id: 'private-crm',
+      access: 'internal',
+    });
+
+    expect(axios.get).toHaveBeenNthCalledWith(
+      1,
+      'https://appconnect.labs.ringcentral.com/public-api/connectors/internal?accountId=rc-account-1',
+    );
+    expect(axios.get).toHaveBeenNthCalledWith(
+      2,
+      'https://appconnect.labs.ringcentral.com/public-api/connectors/private-crm/manifest?access=internal&type=connector&accountId=rc-account-1',
+    );
+  });
+
+  test('loads a shared private connector manifest from the owner account', async () => {
+    axios.get
+      .mockResolvedValueOnce({
+        data: {
+          privateConnectors: [],
+          sharedConnectors: [
+            { id: 'shared-crm', accountId: 'owner-account' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          id: 'shared-crm',
+          ownerAccountId: 'owner-account',
+        },
+      });
+
+    await expect(getConnectorManifest({
+      rcAccountId: 'viewer-account',
+      connectorId: 'shared-crm',
+      isPrivate: true,
+    })).resolves.toEqual({
+      id: 'shared-crm',
+      ownerAccountId: 'owner-account',
+    });
+
+    expect(axios.get).toHaveBeenNthCalledWith(
+      2,
+      'https://appconnect.labs.ringcentral.com/public-api/connectors/shared-crm/manifest?access=internal&type=connector&accountId=owner-account',
+    );
+  });
+
+  test('returns null when a private connector is not visible to the account', async () => {
+    axios.get.mockResolvedValueOnce({
+      data: {
+        privateConnectors: [],
+        sharedConnectors: [],
+      },
+    });
+
+    await expect(getConnectorManifest({
+      rcAccountId: 'rc-account-2',
+      connectorId: 'missing-crm',
+      isPrivate: true,
+    })).resolves.toBeNull();
+
+    expect(logger.error.mock.calls[0][0]).toBe('Error getting connector manifest:');
+    expect(logger.error.mock.calls[0][1].message).toBe('Connector not found');
+  });
+
+  test('returns null when public manifest loading fails', async () => {
+    const error = new Error('manifest unavailable');
+    axios.get.mockRejectedValueOnce(error);
+
+    await expect(getConnectorManifest({
+      connectorId: 'broken-crm',
+    })).resolves.toBeNull();
+
+    expect(logger.error).toHaveBeenCalledWith('Error getting connector manifest:', error);
+  });
+});

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'
+      })
+    ]);
+  });
 });