@app-connect/core 1.7.34 → 1.7.36

package/test/handlers/appointment.test.js

@@ -0,0 +1,260 @@
+jest.mock('../../models/userModel', () => ({
+  UserModel: {
+    findByPk: jest.fn()
+  }
+}));
+jest.mock('../../connector/registry', () => ({
+  getConnector: jest.fn()
+}));
+jest.mock('../../lib/oauth', () => ({
+  getOAuthApp: jest.fn(() => ({ app: true })),
+  checkAndRefreshAccessToken: jest.fn()
+}));
+jest.mock('../../models/dynamo/connectorSchema', () => ({
+  Connector: {
+    getProxyConfig: jest.fn()
+  }
+}));
+
+const appointmentHandler = require('../../handlers/appointment');
+const { UserModel } = require('../../models/userModel');
+const connectorRegistry = require('../../connector/registry');
+const oauth = require('../../lib/oauth');
+const { Connector } = require('../../models/dynamo/connectorSchema');
+
+describe('Appointment Handler', () => {
+  const baseUser = {
+    id: 'user-1',
+    hostname: 'crm.example.com',
+    accessToken: 'access-token',
+    platformAdditionalInfo: {}
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  function mockApiKeyConnector(overrides = {}) {
+    const connector = {
+      getAuthType: jest.fn().mockResolvedValue('apiKey'),
+      getBasicAuth: jest.fn(() => 'encoded-key'),
+      listAppointments: jest.fn().mockResolvedValue({ appointments: [{ id: 'appt-1' }] }),
+      createAppointment: jest.fn().mockResolvedValue({ appointmentId: 'appt-2', appointment: { id: 'appt-2' } }),
+      updateAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-3' } }),
+      refreshAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-4' } }),
+      confirmAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-5' } }),
+      cancelAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-6' } }),
+      ...overrides
+    };
+    connectorRegistry.getConnector.mockReturnValue(connector);
+    return connector;
+  }
+
+  test('returns database warning when user lookup fails', async () => {
+    UserModel.findByPk.mockRejectedValueOnce(new Error('db unavailable'));
+
+    const result = await appointmentHandler.listAppointments({
+      platform: 'testCRM',
+      userId: 'user-1'
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.returnMessage.messageType).toBe('warning');
+    expect(result.returnMessage.message).toBe('Database operation failed');
+  });
+
+  test('returns warning when user is missing or session has no token', async () => {
+    UserModel.findByPk.mockResolvedValueOnce(null);
+
+    await expect(appointmentHandler.listAppointments({
+      platform: 'testCRM',
+      userId: 'missing-user'
+    })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        message: 'User not found'
+      }
+    });
+
+    UserModel.findByPk.mockResolvedValueOnce({ id: 'user-1' });
+    const noTokenResult = await appointmentHandler.createAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      payload: { title: 'Meeting' }
+    });
+
+    expect(noTokenResult.successful).toBe(false);
+    expect(noTokenResult.returnMessage.message).toBe('User not found');
+  });
+
+  test('listAppointments resolves oauth auth with proxy config and returns connector result', async () => {
+    const user = {
+      ...baseUser,
+      platformAdditionalInfo: {
+        proxyId: 'proxy-1',
+        tokenUrl: 'https://token.example.com'
+      }
+    };
+    const refreshedUser = {
+      ...user,
+      accessToken: 'fresh-token'
+    };
+    const connector = {
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({ tokenUrl: 'https://token.example.com' }),
+      listAppointments: jest.fn().mockResolvedValue({
+        appointments: [{ id: 'appt-1' }],
+        returnMessage: {
+          messageType: 'success',
+          message: 'Listed'
+        }
+      })
+    };
+    UserModel.findByPk.mockResolvedValue(user);
+    Connector.getProxyConfig.mockResolvedValue({ id: 'proxy-1' });
+    oauth.checkAndRefreshAccessToken.mockResolvedValue(refreshedUser);
+    connectorRegistry.getConnector.mockReturnValue(connector);
+
+    const result = await appointmentHandler.listAppointments({
+      platform: 'testCRM',
+      userId: 'user-1',
+      range: { startDate: '2026-07-01' },
+      mineOnly: true,
+      forceSync: true
+    });
+
+    expect(connector.getOauthInfo).toHaveBeenCalledWith({
+      tokenUrl: 'https://token.example.com',
+      hostname: 'crm.example.com',
+      proxyId: 'proxy-1',
+      proxyConfig: { id: 'proxy-1' }
+    });
+    expect(connector.listAppointments).toHaveBeenCalledWith({
+      user: refreshedUser,
+      authHeader: 'Bearer fresh-token',
+      range: { startDate: '2026-07-01' },
+      mineOnly: true,
+      forceSync: true,
+      proxyConfig: { id: 'proxy-1' }
+    });
+    expect(result).toMatchObject({
+      successful: true,
+      appointments: [{ id: 'appt-1' }]
+    });
+  });
+
+  test('oauth auth returns revoke response when token refresh fails', async () => {
+    const connector = {
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({})
+    };
+    UserModel.findByPk.mockResolvedValue(baseUser);
+    connectorRegistry.getConnector.mockReturnValue(connector);
+    oauth.checkAndRefreshAccessToken.mockResolvedValue(null);
+
+    const result = await appointmentHandler.createAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      payload: { title: 'Meeting' }
+    });
+
+    expect(result).toMatchObject({
+      successful: false,
+      isRevokeUserSession: true,
+      returnMessage: {
+        message: 'User session expired. Please connect again.'
+      }
+    });
+  });
+
+  test('apiKey auth is used by create, update, refresh, confirm, and cancel operations', async () => {
+    UserModel.findByPk.mockResolvedValue(baseUser);
+    const connector = mockApiKeyConnector();
+
+    const createResult = await appointmentHandler.createAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      payload: { title: 'Create' }
+    });
+    const updateResult = await appointmentHandler.updateAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-2',
+      patchBody: { title: 'Update' }
+    });
+    const refreshResult = await appointmentHandler.refreshAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-3'
+    });
+    const confirmResult = await appointmentHandler.confirmAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-4'
+    });
+    const cancelResult = await appointmentHandler.cancelAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-5'
+    });
+
+    expect(createResult.appointmentId).toBe('appt-2');
+    expect(updateResult.appointment).toEqual({ id: 'appt-3' });
+    expect(refreshResult.appointment).toEqual({ id: 'appt-4' });
+    expect(confirmResult.appointment).toEqual({ id: 'appt-5' });
+    expect(cancelResult.appointment).toEqual({ id: 'appt-6' });
+    expect(connector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'access-token' });
+    expect(connector.createAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      payload: { title: 'Create' },
+      proxyConfig: null
+    });
+    expect(connector.updateAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-2',
+      patchBody: { title: 'Update' },
+      proxyConfig: null
+    });
+    expect(connector.refreshAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-3',
+      proxyConfig: null
+    });
+    expect(connector.confirmAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-4',
+      proxyConfig: null
+    });
+    expect(connector.cancelAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-5',
+      proxyConfig: null
+    });
+  });
+
+  test('operation errors are mapped through API error handler', async () => {
+    UserModel.findByPk.mockResolvedValue(baseUser);
+    mockApiKeyConnector({
+      updateAppointment: jest.fn().mockRejectedValue({
+        response: {
+          status: 429
+        }
+      })
+    });
+
+    const result = await appointmentHandler.updateAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-2',
+      patchBody: { title: 'Update' }
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.returnMessage.messageType).toBe('warning');
+  });
+});

package/test/handlers/auth.test.js

@@ -863,8 +863,9 @@ describe('Auth Handler', () => {
     test('should use overriding OAuth option if provided', async () => {
       // Arrange
       const overridingOption = { redirect_uri: 'custom-redirect' };
+      const oauthInfo = { clientId: 'id', clientSecret: 'secret' };
       const mockConnector = global.testUtils.createMockConnector({
-        getOauthInfo: jest.fn().mockResolvedValue({ clientId: 'id', clientSecret: 'secret' }),
+        getOauthInfo: jest.fn().mockResolvedValue(oauthInfo),
         getOverridingOAuthOption: jest.fn().mockReturnValue(overridingOption),
         getUserInfo: jest.fn().mockResolvedValue({
           successful: true,
@@ -892,7 +893,10 @@ describe('Auth Handler', () => {
       await authHandler.onOAuthCallback(requestData);
 
       // Assert
-      expect(mockConnector.getOverridingOAuthOption).toHaveBeenCalledWith({ code: 'code123' });
+      expect(mockConnector.getOverridingOAuthOption).toHaveBeenCalledWith({
+        code: 'code123',
+        oauthInfo: { clientId: 'id', clientSecret: 'secret' }
+      });
       expect(mockOAuthApp.code.getToken).toHaveBeenCalledWith(
         expect.any(String),
         overridingOption

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