@app-connect/core 1.7.35 → 1.7.36

package/test/handlers/log.test.js

@@ -38,6 +38,7 @@ const { composeCallLog } = require('../../lib/callLogComposer');
 const { NoteCache } = require('../../models/dynamo/noteCacheSchema');
 const axios = require('axios');
 const { sequelize } = require('../../models/sequelize');
+const { getHashValue } = require('../../lib/util');
 
 describe('Log Handler', () => {
   beforeAll(async () => {
@@ -170,6 +171,82 @@ describe('Log Handler', () => {
       expect(savedLog.thirdPartyLogId).toBe('new-log-102');
     });
 
+    test('should block duplicate client log when SSCL already logged same hashed extension', async () => {
+      // Arrange
+      const hashedExtensionId = getHashValue('rc-ext-1', 'test-hash-key');
+      await CallLogModel.create({
+        id: 'tel-session-123',
+        sessionId: 'session-123',
+        extensionNumber: '',
+        hashedExtensionId,
+        platform: 'testCRM',
+        thirdPartyLogId: 'sscl-log',
+        userId: 'test-user-id'
+      });
+
+      const incomingData = {
+        ...mockIncomingData,
+        extensionNumber: '101',
+        hashedExtensionId
+      };
+
+      // 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.message).toContain('Existing log for session');
+    });
+
+    test('should derive hashed extension id from SSCL raw rcExtensionId when saving', async () => {
+      // Arrange
+      process.env.HASH_KEY = 'test-hash-key';
+      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-sscl-log',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      const incomingData = {
+        ...mockIncomingData,
+        rcExtensionId: 'rc-ext-1'
+      };
+
+      // Act
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: true
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      const savedLog = await CallLogModel.findOne({
+        where: {
+          sessionId: 'session-123',
+          hashedExtensionId: getHashValue('rc-ext-1', 'test-hash-key')
+        }
+      });
+      expect(savedLog).not.toBeNull();
+      expect(savedLog.thirdPartyLogId).toBe('new-sscl-log');
+    });
+
     test('should return warning when user not found', async () => {
       // Act
       const result = await logHandler.createCallLog({
@@ -419,6 +496,53 @@ describe('Log Handler', () => {
       }
     });
 
+    test('should mark async plugin task failed when token sync URL is missing', async () => {
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: mockUser.rcAccountId,
+        platformName: 'asyncPlugin',
+        dataKey: 'pluginData',
+        data: {
+          name: 'plugin.async',
+          supportedLogTypes: ['call'],
+          isAsync: true,
+          endpointUrl: 'https://plugins.example.com/plugin/asyncPlugin',
+          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-async-failed',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      expect(result.successful).toBe(true);
+      const cache = await CacheModel.findOne({
+        where: {
+          cacheKey: 'asyncPluginTask-asyncPlugin'
+        }
+      });
+      expect(cache).not.toBeNull();
+      expect(cache.status).toBe('failed');
+      expect(cache.data.message).toBe('Plugin token sync URL is not set');
+      expect(axios.post).not.toHaveBeenCalled();
+    });
+
     test('should successfully create call log with oauth auth', async () => {
       // Arrange
       const oauthUser = { ...mockUser };
@@ -617,6 +741,43 @@ describe('Log Handler', () => {
       }]);
     });
 
+    test('should match SSCL log by hashedExtensionId when extensionNumber differs', async () => {
+      // Arrange
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token'
+      });
+
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        extensionNumber: '',
+        hashedExtensionId: 'hashed-ext-1',
+        platform: 'testCRM',
+        thirdPartyLogId: 'sscl-log',
+        userId: 'test-user-id'
+      });
+
+      // Act
+      const result = await logHandler.getCallLog({
+        userId: 'test-user-id',
+        sessionIds: 'session-1',
+        extensionNumber: '101',
+        hashedExtensionId: 'hashed-ext-1',
+        platform: 'testCRM',
+        requireDetails: false
+      });
+
+      // Assert
+      expect(result.successful).toBe(true);
+      expect(result.logs).toEqual([{
+        sessionId: 'session-1',
+        matched: true,
+        logId: 'sscl-log'
+      }]);
+    });
+
     test('should keep session-only lookup backward compatible when extensionNumber is empty', async () => {
       // Arrange
       await UserModel.create({
@@ -1291,6 +1452,21 @@ describe('Log Handler', () => {
   });
 
   describe('handleAsyncPluginCallback', () => {
+    test('should return not found when callback task cache is missing', async () => {
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'missing-task',
+        body: {
+          successful: true,
+          note: 'Callback note'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 404,
+        body: { successful: false, message: 'Async task not found' }
+      });
+    });
+
     test('should append callback note to call log and remove task cache on success', async () => {
       await UserModel.create({
         id: 'test-user-id',
@@ -1412,6 +1588,154 @@ describe('Log Handler', () => {
       expect(cache.data.message).toBe('Plugin failed');
     });
 
+    test('should destroy expired task cache and return not found', async () => {
+      await CacheModel.create({
+        id: 'task-expired',
+        status: 'pending',
+        userId: 'test-user-id',
+        cacheKey: 'asyncPluginTask-testPlugin',
+        expiry: new Date(Date.now() - 1000),
+        data: {
+          pluginId: 'testPlugin',
+          platform: 'testCRM',
+          userId: 'test-user-id',
+          sessionId: 'session-1'
+        }
+      });
+
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'task-expired',
+        body: {
+          successful: true,
+          note: 'Late callback note'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 404,
+        body: { successful: false, message: 'Async task not found' }
+      });
+      expect(await CacheModel.findByPk('task-expired')).toBeNull();
+      expect(connectorRegistry.getConnector).not.toHaveBeenCalled();
+    });
+
+    test('should mark task failed when callback cannot find the original call log', async () => {
+      await CacheModel.create({
+        id: 'task-missing-log',
+        status: 'pending',
+        userId: 'test-user-id',
+        cacheKey: 'asyncPluginTask-testPlugin',
+        expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+        data: {
+          pluginId: 'testPlugin',
+          platform: 'testCRM',
+          userId: 'test-user-id',
+          sessionId: 'missing-session',
+          extensionNumber: '',
+          incomingData: {
+            logInfo: {
+              sessionId: 'missing-session'
+            }
+          }
+        }
+      });
+
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'task-missing-log',
+        body: {
+          successful: true,
+          note: 'Callback note'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 500,
+        body: { successful: false, message: 'Call log not found for async plugin task' }
+      });
+      const cache = await CacheModel.findByPk('task-missing-log');
+      expect(cache.status).toBe('failed');
+      expect(cache.data.message).toBe('Call log not found for async plugin task');
+      expect(connectorRegistry.getConnector).not.toHaveBeenCalled();
+    });
+
+    test('should mark task failed when callback note cannot be written to CRM', async () => {
+      await UserModel.create({
+        id: 'test-user-id',
+        platform: 'testCRM',
+        accessToken: 'test-token',
+        platformAdditionalInfo: {}
+      });
+      await CallLogModel.create({
+        id: 'call-1',
+        sessionId: 'session-1',
+        extensionNumber: '',
+        platform: 'testCRM',
+        thirdPartyLogId: 'log-1',
+        userId: 'test-user-id',
+        contactId: 'contact-1'
+      });
+      await CacheModel.create({
+        id: 'task-update-failed',
+        status: 'pending',
+        userId: 'test-user-id',
+        cacheKey: 'asyncPluginTask-testPlugin',
+        expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+        data: {
+          pluginId: 'testPlugin',
+          platform: 'testCRM',
+          userId: 'test-user-id',
+          sessionId: 'session-1',
+          extensionNumber: '',
+          incomingData: {
+            logInfo: {
+              sessionId: 'session-1',
+              startTime: '2026-06-12T10:00:00.000Z',
+              duration: 120,
+              result: 'Completed',
+              direction: 'Outbound',
+              from: { phoneNumber: '+1234567890' },
+              to: { phoneNumber: '+1987654321' }
+            },
+            note: 'Original note'
+          },
+          hashedAccountId: 'hashed-123',
+          isFromSSCL: false
+        }
+      });
+      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',
+            fullLogResponse: { id: 'log-1' }
+          }
+        }),
+        updateCallLog: jest.fn().mockRejectedValue(new Error('CRM update failed'))
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Updated composed log');
+
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'task-update-failed',
+        body: {
+          successful: true,
+          note: 'Callback note'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 500,
+        body: { successful: false, message: 'CRM update failed' }
+      });
+      const cache = await CacheModel.findByPk('task-update-failed');
+      expect(cache).not.toBeNull();
+      expect(cache.status).toBe('failed');
+      expect(cache.data.message).toBe('CRM update failed');
+      expect(mockConnector.updateCallLog).toHaveBeenCalled();
+    });
     test('should reject callback without successful boolean', async () => {
       const result = await logHandler.handleAsyncPluginCallback({
         taskId: 'task-1',
@@ -1521,4 +1845,3 @@ describe('Log Handler', () => {
     });
   });
 });
-

package/test/handlers/managedOAuth.test.js

@@ -0,0 +1,262 @@
+jest.mock('../../models/sequelize', () => {
+  const { Sequelize } = require('sequelize');
+  return {
+    sequelize: new Sequelize({
+      dialect: 'sqlite',
+      storage: ':memory:',
+      logging: false
+    })
+  };
+});
+
+const managedOAuth = require('../../handlers/managedOAuth');
+const { AccountDataModel } = require('../../models/accountDataModel');
+const { CacheModel } = require('../../models/cacheModel');
+const { sequelize } = require('../../models/sequelize');
+
+describe('Managed OAuth Handler', () => {
+  beforeAll(async () => {
+    process.env.APP_SERVER_SECRET_KEY = 'test-app-server-secret-key-123456';
+    await AccountDataModel.sync({ force: true });
+    await CacheModel.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    await AccountDataModel.destroy({ where: {} });
+    await CacheModel.destroy({ where: {} });
+  });
+
+  afterAll(async () => {
+    await sequelize.close();
+  });
+
+  test('returns empty state when account and platform are missing', async () => {
+    await expect(managedOAuth.getManagedOAuthState({
+      rcAccountId: '',
+      platform: '',
+      isAdmin: false
+    })).resolves.toEqual({
+      isAdmin: false,
+      hasAccountOAuth: false,
+      hasPendingOAuth: false
+    });
+
+    await expect(managedOAuth.clearPendingManagedOAuth({})).resolves.toBe(0);
+    await expect(managedOAuth.clearAccountManagedOAuth({ rcAccountId: 'acc-1' })).resolves.toBe(0);
+  });
+
+  test('upserts pending OAuth values, filters empty fields, and exposes pending values to admin', async () => {
+    const firstRecord = await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-1',
+      values: {
+        clientId: 'client-id',
+        clientSecret: 'client-secret',
+        accessTokenUri: '',
+        authorizationUri: 'https://auth.example.com',
+        ignored: 'ignored'
+      }
+    });
+
+    expect(firstRecord.id).toBe('acc-1-managed-oauth-account');
+
+    const secondRecord = await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-1',
+      values: {
+        clientId: 'client-id-2',
+        redirectUri: 'https://app.example.com/callback',
+        scopes: ['read', 'write'],
+        hostname: 'crm.example.com'
+      }
+    });
+
+    expect(secondRecord.id).toBe(firstRecord.id);
+
+    const pendingValues = await managedOAuth.getPendingManagedOAuthValues({ rcAccountId: 'acc-1' });
+    expect(pendingValues).toEqual({
+      clientId: 'client-id-2',
+      redirectUri: 'https://app.example.com/callback',
+      scopes: ['read', 'write'],
+      hostname: 'crm.example.com'
+    });
+
+    const state = await managedOAuth.getManagedOAuthState({
+      rcAccountId: 'acc-1',
+      platform: 'testCRM',
+      isAdmin: true
+    });
+
+    expect(state).toEqual({
+      isAdmin: true,
+      hasAccountOAuth: false,
+      hasPendingOAuth: true,
+      pendingValues
+    });
+  });
+
+  test('expired pending OAuth cache is destroyed and ignored', async () => {
+    const record = await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'expired-acc',
+      values: {
+        clientId: 'expired-client'
+      }
+    });
+    await record.update({
+      expiry: new Date(Date.now() - 1000)
+    });
+
+    const values = await managedOAuth.getPendingManagedOAuthValues({ rcAccountId: 'expired-acc' });
+
+    expect(values).toEqual({});
+    expect(await CacheModel.findByPk('expired-acc-managed-oauth-account')).toBeNull();
+  });
+
+  test('migrates pending OAuth to account record and hides account client secret in state', async () => {
+    await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-2',
+      values: {
+        clientId: 'client-id',
+        clientSecret: 'client-secret',
+        accessTokenUri: 'https://token.example.com'
+      }
+    });
+
+    await expect(managedOAuth.migratePendingManagedOAuth({
+      rcAccountId: 'acc-2',
+      platform: 'testCRM'
+    })).resolves.toBe(true);
+
+    expect(await managedOAuth.getPendingManagedOAuthValues({ rcAccountId: 'acc-2' })).toEqual({});
+
+    const accountValues = await managedOAuth.getAccountManagedOAuthValues({
+      rcAccountId: 'acc-2',
+      platform: 'testCRM'
+    });
+    expect(accountValues).toEqual({
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      accessTokenUri: 'https://token.example.com'
+    });
+
+    const state = await managedOAuth.getManagedOAuthState({
+      rcAccountId: 'acc-2',
+      platform: 'testCRM',
+      isAdmin: true
+    });
+
+    expect(state).toEqual({
+      isAdmin: true,
+      hasAccountOAuth: true,
+      hasPendingOAuth: false,
+      oauthValues: {
+        clientId: 'client-id',
+        accessTokenUri: 'https://token.example.com'
+      }
+    });
+  });
+
+  test('migrates pending OAuth into an existing account record and resolves account source first', async () => {
+    await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-3',
+      values: {
+        clientId: 'pending-client'
+      }
+    });
+    await AccountDataModel.create({
+      rcAccountId: 'acc-3',
+      platformName: 'testCRM',
+      dataKey: managedOAuth.MANAGED_OAUTH_ACCOUNT_DATA_KEY,
+      data: {
+        fields: {
+          clientId: {
+            encrypted: false,
+            value: 'old-client'
+          }
+        }
+      }
+    });
+
+    await expect(managedOAuth.migratePendingManagedOAuth({
+      rcAccountId: 'acc-3',
+      platform: 'testCRM'
+    })).resolves.toBe(true);
+
+    await expect(managedOAuth.resolveManagedOAuthInfo({
+      rcAccountId: 'acc-3',
+      platform: 'testCRM'
+    })).resolves.toEqual({
+      source: 'account',
+      oauthInfo: {
+        clientId: 'pending-client'
+      }
+    });
+  });
+
+  test('resolveManagedOAuthInfo falls back to pending values or null source', async () => {
+    await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-4',
+      values: {
+        clientId: 'pending-client'
+      }
+    });
+
+    await expect(managedOAuth.resolveManagedOAuthInfo({
+      rcAccountId: 'acc-4',
+      platform: 'testCRM'
+    })).resolves.toEqual({
+      source: 'pending',
+      oauthInfo: {
+        clientId: 'pending-client'
+      }
+    });
+
+    await expect(managedOAuth.resolveManagedOAuthInfo({
+      rcAccountId: 'missing-acc',
+      platform: 'testCRM'
+    })).resolves.toEqual({
+      source: null,
+      oauthInfo: null
+    });
+  });
+
+  test('clear and reset delete account and pending OAuth data', async () => {
+    await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-5',
+      values: {
+        clientId: 'pending-client'
+      }
+    });
+    await managedOAuth.migratePendingManagedOAuth({
+      rcAccountId: 'acc-5',
+      platform: 'testCRM'
+    });
+    await managedOAuth.upsertPendingManagedOAuth({
+      rcAccountId: 'acc-5',
+      values: {
+        clientId: 'pending-client-2'
+      }
+    });
+
+    const resetResult = await managedOAuth.resetManagedOAuth({
+      rcAccountId: 'acc-5',
+      platform: 'testCRM'
+    });
+
+    expect(resetResult).toEqual({
+      deletedAccountCount: 1,
+      deletedPendingCount: 1
+    });
+  });
+
+  test('throws when upserting pending OAuth without account id and no-ops missing migrations', async () => {
+    await expect(managedOAuth.upsertPendingManagedOAuth({
+      values: {
+        clientId: 'client-id'
+      }
+    })).rejects.toThrow('rcAccountId is required');
+
+    await expect(managedOAuth.migratePendingManagedOAuth({
+      rcAccountId: 'no-pending',
+      platform: 'testCRM'
+    })).resolves.toBe(false);
+  });
+});