@app-connect/core 1.7.35 → 1.7.37

package/test/handlers/calldown.test.js

@@ -0,0 +1,310 @@
+const calldown = require('../../handlers/calldown');
+const { generateJwt } = require('../../lib/jwt');
+const { CallDownListModel } = require('../../models/callDownListModel');
+const { UserModel } = require('../../models/userModel');
+
+describe('Calldown Handler', () => {
+  const originalSecret = process.env.APP_SERVER_SECRET_KEY;
+
+  beforeAll(async () => {
+    process.env.APP_SERVER_SECRET_KEY = 'test-app-server-secret-key-123456';
+    await UserModel.sync({ force: true });
+    await CallDownListModel.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    await CallDownListModel.destroy({ where: {} });
+    await UserModel.destroy({ where: {} });
+    jest.restoreAllMocks();
+  });
+
+  afterAll(() => {
+    if (originalSecret === undefined) {
+      delete process.env.APP_SERVER_SECRET_KEY;
+    } else {
+      process.env.APP_SERVER_SECRET_KEY = originalSecret;
+    }
+  });
+
+  function tokenFor(userId) {
+    return generateJwt({
+      id: userId,
+      platform: 'testCRM',
+    });
+  }
+
+  async function createUser(id = 'user-1') {
+    return UserModel.create({
+      id,
+      platform: 'testCRM',
+      accessToken: 'token',
+    });
+  }
+
+  test('schedule creates a scheduled record for the JWT user', async () => {
+    await createUser('user-1');
+
+    const result = await calldown.schedule({
+      jwtToken: tokenFor('user-1'),
+      body: {
+        contactId: 12345,
+        contactType: 'Lead',
+        contactName: 'Ignored By Current Schema',
+        phoneNumber: '+15551234567',
+        scheduledAt: '2026-07-02T13:00:00.000Z',
+      },
+    });
+
+    expect(result.id).toMatch(/^[0-9a-f]{32}$/);
+    const record = await CallDownListModel.findByPk(result.id);
+    expect(record).toMatchObject({
+      id: result.id,
+      userId: 'user-1',
+      contactId: '12345',
+      contactType: 'Lead',
+      status: 'scheduled',
+    });
+    expect(record.scheduledAt.toISOString()).toBe('2026-07-02T13:00:00.000Z');
+    expect(record.lastCallAt).toBeNull();
+  });
+
+  test('schedule uses current defaults for optional body fields', async () => {
+    await createUser('user-1');
+
+    const result = await calldown.schedule({
+      jwtToken: tokenFor('user-1'),
+      body: {},
+    });
+
+    const record = await CallDownListModel.findByPk(result.id);
+    expect(record.contactId).toBeNull();
+    expect(record.contactType).toBe('contact');
+    expect(record.status).toBe('scheduled');
+    expect(record.scheduledAt).toBeNull();
+  });
+
+  test('schedule rejects invalid jwt and missing users', async () => {
+    await expect(calldown.schedule({
+      jwtToken: 'not-a-valid-token',
+      body: {},
+    })).rejects.toThrow('Unauthorized');
+
+    await expect(calldown.schedule({
+      jwtToken: tokenFor('missing-user'),
+      body: {},
+    })).rejects.toThrow('User not found');
+  });
+
+  test('list returns all records for the JWT user ordered by scheduledAt', async () => {
+    await createUser('user-1');
+    await createUser('user-2');
+    await CallDownListModel.bulkCreate([
+      {
+        id: 'later',
+        userId: 'user-1',
+        contactId: 'contact-2',
+        status: 'called',
+        scheduledAt: new Date('2026-07-02T14:00:00.000Z'),
+      },
+      {
+        id: 'earlier',
+        userId: 'user-1',
+        contactId: 'contact-1',
+        status: 'scheduled',
+        scheduledAt: new Date('2026-07-02T13:00:00.000Z'),
+      },
+      {
+        id: 'other-user',
+        userId: 'user-2',
+        contactId: 'contact-3',
+        status: 'scheduled',
+        scheduledAt: new Date('2026-07-02T12:00:00.000Z'),
+      },
+    ]);
+
+    const { items } = await calldown.list({
+      jwtToken: tokenFor('user-1'),
+    });
+
+    expect(items.map((item) => item.id)).toEqual(['earlier', 'later']);
+  });
+
+  test('list filters called and not-called statuses according to current implementation', async () => {
+    await createUser('user-1');
+    await CallDownListModel.bulkCreate([
+      {
+        id: 'called',
+        userId: 'user-1',
+        status: 'called',
+        scheduledAt: new Date('2026-07-02T13:00:00.000Z'),
+      },
+      {
+        id: 'scheduled',
+        userId: 'user-1',
+        status: 'scheduled',
+        scheduledAt: new Date('2026-07-02T14:00:00.000Z'),
+      },
+      {
+        id: 'removed-status',
+        userId: 'user-1',
+        status: 'removed',
+        scheduledAt: new Date('2026-07-02T15:00:00.000Z'),
+      },
+    ]);
+
+    const called = await calldown.list({
+      jwtToken: tokenFor('user-1'),
+      status: 'called',
+    });
+    const notCalled = await calldown.list({
+      jwtToken: tokenFor('user-1'),
+      status: 'not_called',
+    });
+
+    expect(called.items.map((item) => item.id)).toEqual(['called']);
+    expect(notCalled.items.map((item) => item.id)).toEqual(['scheduled', 'removed-status']);
+  });
+
+  test('remove physically deletes only records owned by the JWT user', async () => {
+    await createUser('user-1');
+    await createUser('user-2');
+    await CallDownListModel.bulkCreate([
+      {
+        id: 'owned-record',
+        userId: 'user-1',
+        status: 'scheduled',
+      },
+      {
+        id: 'other-record',
+        userId: 'user-2',
+        status: 'scheduled',
+      },
+    ]);
+
+    await expect(calldown.remove({
+      jwtToken: tokenFor('user-1'),
+      id: 'other-record',
+    })).rejects.toThrow('Not found');
+
+    await expect(calldown.remove({
+      jwtToken: tokenFor('user-1'),
+      id: 'owned-record',
+    })).resolves.toEqual({ successful: true });
+
+    await expect(CallDownListModel.findByPk('owned-record')).resolves.toBeNull();
+    await expect(CallDownListModel.findByPk('other-record')).resolves.not.toBeNull();
+  });
+
+  test('markCalled updates status and lastCallAt for owned records', async () => {
+    await createUser('user-1');
+    await CallDownListModel.create({
+      id: 'call-to-mark',
+      userId: 'user-1',
+      status: 'scheduled',
+    });
+
+    const result = await calldown.markCalled({
+      jwtToken: tokenFor('user-1'),
+      id: 'call-to-mark',
+      lastCallAt: '2026-07-02T14:30:00.000Z',
+    });
+
+    expect(result).toEqual({ successful: true });
+    const record = await CallDownListModel.findByPk('call-to-mark');
+    expect(record.status).toBe('called');
+    expect(record.lastCallAt.toISOString()).toBe('2026-07-02T14:30:00.000Z');
+  });
+
+  test('markCalled preserves owner isolation and returns the current database error shape', async () => {
+    await createUser('user-1');
+    await createUser('user-2');
+    await CallDownListModel.create({
+      id: 'other-user-call',
+      userId: 'user-2',
+      status: 'scheduled',
+    });
+
+    const result = await calldown.markCalled({
+      jwtToken: tokenFor('user-1'),
+      id: 'other-user-call',
+    });
+
+    expect(result).toEqual({
+      successful: false,
+      returnMessage: {
+        message: 'Database operation failed',
+        messageType: 'warning',
+        ttl: 5000,
+      },
+    });
+    const record = await CallDownListModel.findByPk('other-user-call');
+    expect(record.status).toBe('scheduled');
+    expect(record.lastCallAt).toBeNull();
+  });
+
+  test('update applies allowed fields and ignores disallowed fields', async () => {
+    await createUser('user-1');
+    await CallDownListModel.create({
+      id: 'call-to-update',
+      userId: 'user-1',
+      contactId: 'old-contact',
+      contactType: 'Lead',
+      status: 'scheduled',
+      scheduledAt: new Date('2026-07-02T13:00:00.000Z'),
+    });
+
+    const result = await calldown.update({
+      jwtToken: tokenFor('user-1'),
+      id: 'call-to-update',
+      updateData: {
+        contactId: 'new-contact',
+        contactType: 'Contact',
+        status: 'called',
+        scheduledAt: '2026-07-02T15:00:00.000Z',
+        lastCallAt: '2026-07-02T15:10:00.000Z',
+        unexpectedField: 'ignored',
+      },
+    });
+
+    expect(result).toEqual({ successful: true });
+    const record = await CallDownListModel.findByPk('call-to-update');
+    expect(record).toMatchObject({
+      contactId: 'new-contact',
+      contactType: 'Contact',
+      status: 'called',
+    });
+    expect(record.scheduledAt.toISOString()).toBe('2026-07-02T15:00:00.000Z');
+    expect(record.lastCallAt.toISOString()).toBe('2026-07-02T15:10:00.000Z');
+    expect(record.unexpectedField).toBeUndefined();
+  });
+
+  test('update rejects no-op and cross-owner updates', async () => {
+    await createUser('user-1');
+    await createUser('user-2');
+    await CallDownListModel.create({
+      id: 'other-user-update',
+      userId: 'user-2',
+      status: 'scheduled',
+    });
+
+    await expect(calldown.update({
+      jwtToken: tokenFor('user-1'),
+      id: 'other-user-update',
+      updateData: {
+        status: 'called',
+      },
+    })).rejects.toThrow('Not found');
+
+    await expect(calldown.update({
+      jwtToken: tokenFor('user-1'),
+      id: 'other-user-update',
+      updateData: {
+        unexpectedField: 'ignored',
+      },
+    })).rejects.toThrow('No valid fields to update');
+
+    const record = await CallDownListModel.findByPk('other-user-update');
+    expect(record.status).toBe('scheduled');
+  });
+});
+

package/test/handlers/disposition.test.js

@@ -0,0 +1,396 @@
+jest.mock('../../lib/oauth');
+jest.mock('../../models/dynamo/connectorSchema', () => ({
+  Connector: {
+    getProxyConfig: jest.fn(),
+  },
+}));
+
+const disposition = require('../../handlers/disposition');
+const connectorRegistry = require('../../connector/registry');
+const oauth = require('../../lib/oauth');
+const { Connector } = require('../../models/dynamo/connectorSchema');
+const { CallLogModel } = require('../../models/callLogModel');
+const { UserModel } = require('../../models/userModel');
+
+describe('Disposition Handler', () => {
+  beforeAll(async () => {
+    await UserModel.sync({ force: true });
+    await CallLogModel.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    await CallLogModel.destroy({ where: {} });
+    await UserModel.destroy({ where: {} });
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+  });
+
+  async function createUser(overrides = {}) {
+    return UserModel.create({
+      id: 'user-1',
+      platform: 'testCRM',
+      hostname: 'crm.example.com',
+      accessToken: 'access-token',
+      platformAdditionalInfo: {},
+      ...overrides,
+    });
+  }
+
+  async function createCallLog(overrides = {}) {
+    return CallLogModel.create({
+      id: 'call-log-1',
+      sessionId: 'session-1',
+      extensionNumber: '',
+      hashedExtensionId: '',
+      platform: 'testCRM',
+      thirdPartyLogId: 'third-party-log-1',
+      userId: 'user-1',
+      contactId: 'contact-1',
+      ...overrides,
+    });
+  }
+
+  function mockApiKeyConnector(overrides = {}) {
+    return {
+      getAuthType: jest.fn().mockResolvedValue('apiKey'),
+      getBasicAuth: jest.fn().mockReturnValue('encoded-api-key'),
+      upsertCallDisposition: jest.fn().mockResolvedValue({
+        logId: 'disposition-log-1',
+        returnMessage: {
+          message: 'Disposition saved',
+          messageType: 'success',
+          ttl: 2000,
+        },
+        extraDataTracking: {
+          providerStatus: 'updated',
+        },
+      }),
+      ...overrides,
+    };
+  }
+
+  test('returns a warning when no matching call log exists', async () => {
+    await createUser();
+    const getConnectorSpy = jest.spyOn(connectorRegistry, 'getConnector');
+
+    const result = await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'missing-session',
+      dispositions: [{ id: 'disposition-1' }],
+    });
+
+    expect(result).toEqual({
+      successful: false,
+      returnMessage: {
+        message: 'Cannot find log',
+        messageType: 'warning',
+        ttl: 3000,
+      },
+    });
+    expect(getConnectorSpy).not.toHaveBeenCalled();
+  });
+
+  test('returns a warning when the matching call log exists but user is missing', async () => {
+    await createCallLog();
+    const getConnectorSpy = jest.spyOn(connectorRegistry, 'getConnector');
+
+    const result = await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'missing-user',
+      sessionId: 'session-1',
+      dispositions: [{ id: 'disposition-1' }],
+    });
+
+    expect(result).toEqual({
+      successful: false,
+      returnMessage: {
+        message: 'Cannot find user',
+        messageType: 'warning',
+        ttl: 3000,
+      },
+    });
+    expect(getConnectorSpy).not.toHaveBeenCalled();
+  });
+
+  test('upserts dispositions with apiKey auth and existing call log', async () => {
+    await createUser();
+    const existingCallLog = await createCallLog({
+      extensionNumber: '101',
+    });
+    const connector = mockApiKeyConnector();
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+    const dispositions = [
+      { id: 'disp-1', value: 'Interested' },
+    ];
+
+    const result = await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      dispositions,
+    });
+
+    expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
+    expect(connector.getAuthType).toHaveBeenCalledWith({
+      proxyId: undefined,
+      proxyConfig: null,
+    });
+    expect(connector.getBasicAuth).toHaveBeenCalledWith({
+      apiKey: 'access-token',
+    });
+    expect(connector.upsertCallDisposition).toHaveBeenCalledWith({
+      user: expect.objectContaining({ id: 'user-1' }),
+      existingCallLog: expect.objectContaining({
+        id: existingCallLog.id,
+        sessionId: 'session-1',
+        extensionNumber: '101',
+      }),
+      authHeader: 'Basic encoded-api-key',
+      dispositions,
+      proxyConfig: null,
+    });
+    expect(result).toEqual({
+      successful: true,
+      logId: 'disposition-log-1',
+      returnMessage: {
+        message: 'Disposition saved',
+        messageType: 'success',
+        ttl: 2000,
+      },
+      extraDataTracking: {
+        providerStatus: 'updated',
+      },
+    });
+  });
+
+  test('returns unsuccessful when provider upsert does not return a log id', async () => {
+    await createUser();
+    await createCallLog();
+    const connector = mockApiKeyConnector({
+      upsertCallDisposition: jest.fn().mockResolvedValue({
+        returnMessage: {
+          message: 'Provider did not update disposition',
+          messageType: 'warning',
+          ttl: 3000,
+        },
+      }),
+    });
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+
+    const result = await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.logId).toBeUndefined();
+    expect(result.returnMessage.message).toBe('Provider did not update disposition');
+  });
+
+  test('matches call log by hashed extension id when extension number differs', async () => {
+    await createUser();
+    await createCallLog({
+      id: 'hashed-call-log',
+      extensionNumber: '',
+      hashedExtensionId: 'hashed-extension-1',
+    });
+    const connector = mockApiKeyConnector();
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+
+    await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'hashed-extension-1',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(connector.upsertCallDisposition).toHaveBeenCalledWith(expect.objectContaining({
+      existingCallLog: expect.objectContaining({
+        id: 'hashed-call-log',
+        hashedExtensionId: 'hashed-extension-1',
+      }),
+    }));
+  });
+
+  test('falls back to legacy extension-number match when hashed extension id is provided', async () => {
+    await createUser();
+    await createCallLog({
+      id: 'legacy-extension-call-log',
+      extensionNumber: '101',
+      hashedExtensionId: '',
+    });
+    const connector = mockApiKeyConnector();
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+
+    await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'new-hashed-extension',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(connector.upsertCallDisposition).toHaveBeenCalledWith(expect.objectContaining({
+      existingCallLog: expect.objectContaining({
+        id: 'legacy-extension-call-log',
+        extensionNumber: '101',
+        hashedExtensionId: '',
+      }),
+    }));
+  });
+
+  test('uses OAuth app and refreshed access token for oauth connectors', async () => {
+    await createUser({
+      accessToken: 'old-access-token',
+      refreshToken: 'refresh-token',
+      platformAdditionalInfo: {
+        tokenUrl: 'https://crm.example.com/oauth/token',
+      },
+    });
+    await createCallLog();
+    const connector = mockApiKeyConnector({
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({
+        clientId: 'client-id',
+        clientSecret: 'client-secret',
+      }),
+    });
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+    const oauthApp = { app: true };
+    oauth.getOAuthApp.mockReturnValue(oauthApp);
+    oauth.checkAndRefreshAccessToken.mockResolvedValue({
+      id: 'user-1',
+      accessToken: 'refreshed-access-token',
+    });
+
+    await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(connector.getOauthInfo).toHaveBeenCalledWith({
+      tokenUrl: 'https://crm.example.com/oauth/token',
+      hostname: 'crm.example.com',
+      proxyId: undefined,
+      proxyConfig: null,
+    });
+    expect(oauth.getOAuthApp).toHaveBeenCalledWith({
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+    });
+    expect(oauth.checkAndRefreshAccessToken).toHaveBeenCalledWith(oauthApp, expect.objectContaining({
+      id: 'user-1',
+      accessToken: 'old-access-token',
+    }));
+    expect(connector.upsertCallDisposition).toHaveBeenCalledWith(expect.objectContaining({
+      authHeader: 'Bearer refreshed-access-token',
+      user: expect.objectContaining({
+        accessToken: 'refreshed-access-token',
+      }),
+    }));
+  });
+
+  test('returns revoke-session warning when OAuth refresh cannot return a user', async () => {
+    await createUser();
+    await createCallLog();
+    const connector = mockApiKeyConnector({
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({}),
+    });
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+    oauth.getOAuthApp.mockReturnValue({});
+    oauth.checkAndRefreshAccessToken.mockResolvedValue(null);
+
+    const result = await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(result).toEqual({
+      successful: false,
+      returnMessage: {
+        message: 'User session expired. Please connect again.',
+        messageType: 'warning',
+        ttl: 5000,
+      },
+      isRevokeUserSession: true,
+    });
+    expect(connector.upsertCallDisposition).not.toHaveBeenCalled();
+  });
+
+  test('loads proxy config and passes it to connector methods', async () => {
+    await createUser({
+      platformAdditionalInfo: {
+        proxyId: 'proxy-1',
+      },
+    });
+    await createCallLog();
+    const proxyConfig = {
+      operations: {
+        upsertCallDisposition: { method: 'POST' },
+      },
+    };
+    Connector.getProxyConfig.mockResolvedValue(proxyConfig);
+    const connector = mockApiKeyConnector();
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+
+    await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(Connector.getProxyConfig).toHaveBeenCalledWith('proxy-1');
+    expect(connector.getAuthType).toHaveBeenCalledWith({
+      proxyId: 'proxy-1',
+      proxyConfig,
+    });
+    expect(connector.upsertCallDisposition).toHaveBeenCalledWith(expect.objectContaining({
+      proxyConfig,
+    }));
+  });
+
+  test('maps provider failures through the API error handler', async () => {
+    await createUser();
+    await createCallLog();
+    const providerError = new Error('provider unauthorized');
+    providerError.response = {
+      status: 401,
+      data: {
+        message: 'Unauthorized',
+      },
+    };
+    const connector = mockApiKeyConnector({
+      upsertCallDisposition: jest.fn().mockRejectedValue(providerError),
+    });
+    jest.spyOn(connectorRegistry, 'getConnector').mockReturnValue(connector);
+
+    const result = await disposition.upsertCallDisposition({
+      platform: 'testCRM',
+      userId: 'user-1',
+      sessionId: 'session-1',
+      extensionNumber: '101',
+      hashedExtensionId: 'hashed-extension-1',
+      dispositions: [{ id: 'disp-1' }],
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.returnMessage.message).toBe('Authorization error');
+    expect(result.extraDataTracking).toEqual({
+      statusCode: 401,
+    });
+  });
+});
+