@app-connect/core 1.7.32 → 1.7.34

package/test/handlers/log.test.js

@@ -31,6 +31,7 @@ const { CallLogModel } = require('../../models/callLogModel');
 const { MessageLogModel } = require('../../models/messageLogModel');
 const { UserModel } = require('../../models/userModel');
 const { AccountDataModel } = require('../../models/accountDataModel');
+const { CacheModel } = require('../../models/cacheModel');
 const connectorRegistry = require('../../connector/registry');
 const oauth = require('../../lib/oauth');
 const { composeCallLog } = require('../../lib/callLogComposer');
@@ -44,6 +45,7 @@ describe('Log Handler', () => {
     await MessageLogModel.sync({ force: true });
     await UserModel.sync({ force: true });
     await AccountDataModel.sync({ force: true });
+    await CacheModel.sync({ force: true });
   });
 
   afterEach(async () => {
@@ -51,6 +53,7 @@ describe('Log Handler', () => {
     await MessageLogModel.destroy({ where: {} });
     await UserModel.destroy({ where: {} });
     await AccountDataModel.destroy({ where: {} });
+    await CacheModel.destroy({ where: {} });
     jest.clearAllMocks();
   });
 
@@ -330,6 +333,91 @@ describe('Log Handler', () => {
       );
     });
 
+    test('should create async task cache and pass task details to async call plugin after log creation', async () => {
+      const originalAppServer = process.env.APP_SERVER;
+      process.env.APP_SERVER = 'https://app.example.com';
+      try {
+        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',
+            tokenSyncUrl: 'https://plugins.example.com/plugin/asyncPlugin/token',
+            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',
+            returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+          })
+        };
+        connectorRegistry.getConnector.mockReturnValue(mockConnector);
+        composeCallLog.mockReturnValue('Composed log details');
+        axios.post.mockImplementation((url) => {
+          if (url === 'https://plugins.example.com/plugin/asyncPlugin/token') {
+            return Promise.resolve({
+              headers: {
+                'x-refreshed-jwt-token': 'synced-plugin-jwt'
+              }
+            });
+          }
+          return Promise.resolve({ data: { accepted: true }, headers: {} });
+        });
+
+        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('pending');
+        expect(cache.userId).toBe('test-user-id');
+        expect(cache.data.pluginId).toBe('asyncPlugin');
+        expect(cache.data.sessionId).toBe('session-123');
+        expect(cache.data.thirdPartyLogId).toBe('new-log-async');
+        expect(cache.expiry.getTime() - Date.now()).toBeGreaterThan(6 * 24 * 60 * 60 * 1000);
+
+        const pluginCall = axios.post.mock.calls.find(([url]) => url === 'https://plugins.example.com/plugin/asyncPlugin');
+        expect(pluginCall).toBeTruthy();
+        expect(pluginCall[1]).toEqual({
+          data: mockIncomingData,
+          config: null,
+          asyncTaskId: cache.id,
+          callbackUrl: `https://app.example.com/plugin/async-callback/${cache.id}`
+        });
+        expect(pluginCall[2]).toEqual({
+          headers: {
+            Authorization: 'Bearer synced-plugin-jwt'
+          }
+        });
+      } finally {
+        if (originalAppServer) {
+          process.env.APP_SERVER = originalAppServer;
+        } else {
+          delete process.env.APP_SERVER;
+        }
+      }
+    });
+
     test('should successfully create call log with oauth auth', async () => {
       // Arrange
       const oauthUser = { ...mockUser };
@@ -1201,6 +1289,143 @@ describe('Log Handler', () => {
     });
   });
 
+  describe('handleAsyncPluginCallback', () => {
+    test('should append callback note to call log and remove task cache on success', 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-1',
+        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: '- Note: Existing note\n- Summary: Existing summary',
+            note: 'Existing note',
+            fullLogResponse: { id: 'log-1' }
+          }
+        }),
+        updateCallLog: jest.fn().mockResolvedValue({
+          updatedNote: 'Existing note\n\nCallback note'
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Updated composed log');
+
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'task-1',
+        body: {
+          successful: true,
+          message: 'Done',
+          note: 'Callback note'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 200,
+        body: { successful: true }
+      });
+      expect(composeCallLog).toHaveBeenCalledWith(expect.objectContaining({
+        existingBody: '- Note: Existing note\n- Summary: Existing summary',
+        note: 'Existing note\n\nCallback note'
+      }));
+      expect(mockConnector.updateCallLog).toHaveBeenCalledWith(expect.objectContaining({
+        note: 'Existing note\n\nCallback note',
+        composedLogDetails: 'Updated composed log',
+        existingCallLogDetails: { id: 'log-1' }
+      }));
+      expect(await CacheModel.findByPk('task-1')).toBeNull();
+    });
+
+    test('should mark task cache failed when callback reports failure', async () => {
+      await CacheModel.create({
+        id: 'task-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'
+        }
+      });
+
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'task-failed',
+        body: {
+          successful: false,
+          message: 'Plugin failed',
+          note: 'Ignored note'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 200,
+        body: { successful: true }
+      });
+      const cache = await CacheModel.findByPk('task-failed');
+      expect(cache.status).toBe('failed');
+      expect(cache.data.message).toBe('Plugin failed');
+    });
+
+    test('should reject callback without successful boolean', async () => {
+      const result = await logHandler.handleAsyncPluginCallback({
+        taskId: 'task-1',
+        body: {
+          message: 'Missing status'
+        }
+      });
+
+      expect(result).toEqual({
+        statusCode: 400,
+        body: { successful: false, message: 'successful is required' }
+      });
+    });
+  });
+
   describe('Error Handling', () => {
     test('should handle 429 rate limit error in createCallLog', async () => {
       // Arrange

package/test/handlers/plugin.test.js

@@ -34,262 +34,6 @@ describe('Plugin Handler', () => {
     await sequelize.close();
   });
 
-  describe('getPluginAsyncTasks', () => {
-    test('should retrieve async task status by IDs from CacheModel', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-task-1',
-        status: 'processing',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-googleDrive'
-      });
-      await CacheModel.create({
-        id: 'user-123-task-2',
-        status: 'completed',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-piiRedaction'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-task-1', 'user-123-task-2']
-      });
-
-      // Assert
-      expect(result).toHaveLength(2);
-      expect(result).toContainEqual({ cacheKey: 'pluginTask-googleDrive', status: 'processing' });
-      expect(result).toContainEqual({ cacheKey: 'pluginTask-piiRedaction', status: 'completed' });
-    });
-
-    test('should return empty array when no matching tasks found', async () => {
-      // Arrange - no tasks created
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['non-existent-task-1', 'non-existent-task-2']
-      });
-
-      // Assert
-      expect(result).toEqual([]);
-    });
-
-    test('should filter and return only tasks with matching IDs', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-task-1',
-        status: 'processing',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-googleDrive'
-      });
-      await CacheModel.create({
-        id: 'user-456-task-2',
-        status: 'completed',
-        userId: 'user-456',
-        cacheKey: 'pluginTask-piiRedaction'
-      });
-      await CacheModel.create({
-        id: 'user-789-task-3',
-        status: 'failed',
-        userId: 'user-789',
-        cacheKey: 'pluginTask-other'
-      });
-
-      // Act - only request tasks for user-123 and user-789
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-task-1', 'user-789-task-3']
-      });
-
-      // Assert
-      expect(result).toHaveLength(2);
-      expect(result).toContainEqual({ cacheKey: 'pluginTask-googleDrive', status: 'processing' });
-      expect(result).toContainEqual({ cacheKey: 'pluginTask-other', status: 'failed' });
-      expect(result).not.toContainEqual(expect.objectContaining({ cacheKey: 'pluginTask-piiRedaction' }));
-    });
-
-    test('should automatically remove completed tasks from cache after retrieval', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-completed-task',
-        status: 'completed',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-googleDrive'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-completed-task']
-      });
-
-      // Assert - result should contain the task
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ cacheKey: 'pluginTask-googleDrive', status: 'completed' });
-
-      // Verify task was removed from cache
-      const remainingTask = await CacheModel.findByPk('user-123-completed-task');
-      expect(remainingTask).toBeNull();
-    });
-
-    test('should automatically remove failed tasks from cache after retrieval', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-failed-task',
-        status: 'failed',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-piiRedaction'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-failed-task']
-      });
-
-      // Assert - result should contain the task
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ cacheKey: 'pluginTask-piiRedaction', status: 'failed' });
-
-      // Verify task was removed from cache
-      const remainingTask = await CacheModel.findByPk('user-123-failed-task');
-      expect(remainingTask).toBeNull();
-    });
-
-    test('should preserve pending tasks in cache after retrieval', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-pending-task',
-        status: 'pending',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-googleDrive'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-pending-task']
-      });
-
-      // Assert - result should contain the task
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ cacheKey: 'pluginTask-googleDrive', status: 'pending' });
-
-      // Verify task was NOT removed from cache
-      const remainingTask = await CacheModel.findByPk('user-123-pending-task');
-      expect(remainingTask).not.toBeNull();
-      expect(remainingTask.status).toBe('pending');
-    });
-
-    test('should preserve processing tasks in cache after retrieval', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-processing-task',
-        status: 'processing',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-piiRedaction'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-processing-task']
-      });
-
-      // Assert - result should contain the task
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ cacheKey: 'pluginTask-piiRedaction', status: 'processing' });
-
-      // Verify task was NOT removed from cache
-      const remainingTask = await CacheModel.findByPk('user-123-processing-task');
-      expect(remainingTask).not.toBeNull();
-      expect(remainingTask.status).toBe('processing');
-    });
-
-    test('should handle mixed task statuses - remove completed/failed but preserve pending/processing', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'task-completed',
-        status: 'completed',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-1'
-      });
-      await CacheModel.create({
-        id: 'task-failed',
-        status: 'failed',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-2'
-      });
-      await CacheModel.create({
-        id: 'task-pending',
-        status: 'pending',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-3'
-      });
-      await CacheModel.create({
-        id: 'task-processing',
-        status: 'processing',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-4'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['task-completed', 'task-failed', 'task-pending', 'task-processing']
-      });
-
-      // Assert - all tasks should be in result
-      expect(result).toHaveLength(4);
-
-      // Verify completed and failed tasks were removed
-      expect(await CacheModel.findByPk('task-completed')).toBeNull();
-      expect(await CacheModel.findByPk('task-failed')).toBeNull();
-
-      // Verify pending and processing tasks were preserved
-      expect(await CacheModel.findByPk('task-pending')).not.toBeNull();
-      expect(await CacheModel.findByPk('task-processing')).not.toBeNull();
-    });
-
-    test('should handle empty asyncTaskIds array', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'some-task',
-        status: 'completed',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-test'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: []
-      });
-
-      // Assert
-      expect(result).toEqual([]);
-
-      // Verify existing task was not touched
-      const existingTask = await CacheModel.findByPk('some-task');
-      expect(existingTask).not.toBeNull();
-    });
-
-    test('should preserve initialized status tasks in cache', async () => {
-      // Arrange
-      await CacheModel.create({
-        id: 'user-123-initialized-task',
-        status: 'initialized',
-        userId: 'user-123',
-        cacheKey: 'pluginTask-googleDrive'
-      });
-
-      // Act
-      const result = await pluginHandler.getPluginAsyncTasks({
-        asyncTaskIds: ['user-123-initialized-task']
-      });
-
-      // Assert
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ cacheKey: 'pluginTask-googleDrive', status: 'initialized' });
-
-      // Verify task was NOT removed from cache
-      const remainingTask = await CacheModel.findByPk('user-123-initialized-task');
-      expect(remainingTask).not.toBeNull();
-    });
-  });
-
   describe('registerPluginAccount', () => {
     test('should register plugin account and persist plugin jwt token in account data', async () => {
       const rcAccountId = '12345';

package/test/index.test.js

@@ -8,6 +8,9 @@ jest.mock('../lib/jwt', () => ({
 jest.mock('../handlers/auth', () => ({
   authValidation: jest.fn(),
 }));
+jest.mock('../handlers/log', () => ({
+  handleAsyncPluginCallback: jest.fn(),
+}));
 jest.mock('../lib/analytics', () => ({
   init: jest.fn(),
   track: jest.fn(),
@@ -15,6 +18,7 @@ jest.mock('../lib/analytics', () => ({
 
 const jwt = require('../lib/jwt');
 const authCore = require('../handlers/auth');
+const logCore = require('../handlers/log');
 const { createCoreRouter, createCoreMiddleware } = require('../index');
 
 function buildApp() {
@@ -101,5 +105,32 @@ describe('Core Router JWT normalization', () => {
     expect(response.status).toBe(404);
     expect(jwt.decodeJwt).not.toHaveBeenCalled();
   });
+
+  test('should route plugin async callbacks by task id', async () => {
+    logCore.handleAsyncPluginCallback.mockResolvedValue({
+      statusCode: 200,
+      body: { successful: true },
+    });
+    const app = buildApp();
+
+    const response = await request(app)
+      .post('/plugin/async-callback/task-123')
+      .send({
+        successful: true,
+        message: 'Done',
+        note: 'Callback note',
+      });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({ successful: true });
+    expect(logCore.handleAsyncPluginCallback).toHaveBeenCalledWith({
+      taskId: 'task-123',
+      body: {
+        successful: true,
+        message: 'Done',
+        note: 'Callback note',
+      },
+    });
+  });
 });
 

package/test/mcp/mcpHandler.test.js

@@ -0,0 +1,73 @@
+const { handleMcpRequest } = require('../../mcp/mcpHandler');
+
+function mockResponse() {
+  return {
+    status: jest.fn().mockReturnThis(),
+    json: jest.fn(),
+    end: jest.fn(),
+  };
+}
+
+describe('MCP Handler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('tools/list includes output schemas for registered tools', async () => {
+    const req = {
+      body: {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list',
+      },
+      headers: {},
+    };
+    const res = mockResponse();
+
+    await handleMcpRequest(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(200);
+    const response = res.json.mock.calls[0][0];
+    const getHelp = response.result.tools.find(tool => tool.name === 'getHelp');
+    const getPublicConnectors = response.result.tools.find(tool => tool.name === 'getPublicConnectors');
+
+    expect(getHelp.outputSchema).toEqual(expect.objectContaining({
+      type: 'object',
+      required: ['success', 'data'],
+    }));
+    expect(getPublicConnectors.outputSchema.properties).toHaveProperty('serverUrl');
+  });
+
+  test('tools/call returns structuredContent matching the tool output', async () => {
+    const req = {
+      body: {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/call',
+        params: {
+          name: 'getHelp',
+          arguments: {},
+        },
+      },
+      headers: {},
+    };
+    const res = mockResponse();
+
+    await handleMcpRequest(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(200);
+    const response = res.json.mock.calls[0][0];
+
+    expect(response.result.structuredContent).toEqual(expect.objectContaining({
+      success: true,
+      data: expect.objectContaining({
+        overview: expect.any(String),
+        steps: expect.any(Array),
+      }),
+    }));
+    expect(response.result.content[0]).toEqual(expect.objectContaining({
+      type: 'text',
+      text: expect.stringContaining('"success": true'),
+    }));
+  });
+});