@app-connect/core 1.7.34 → 1.7.36

package/test/index.test.js

@@ -20,6 +20,7 @@ const jwt = require('../lib/jwt');
 const authCore = require('../handlers/auth');
 const logCore = require('../handlers/log');
 const { createCoreRouter, createCoreMiddleware } = require('../index');
+const connectorRegistry = require('../connector/registry');
 
 function buildApp() {
   const app = express();
@@ -33,7 +34,7 @@ describe('Core Router JWT normalization', () => {
     jest.clearAllMocks();
   });
 
-  test('should accept query jwtToken without refreshing it', async () => {
+  test('should accept query jwtToken without exp without refreshing it', async () => {
     jwt.decodeJwt.mockReturnValue({ id: 'user-1', platform: 'testCRM' });
     authCore.authValidation.mockResolvedValue({
       successful: true,
@@ -54,6 +55,69 @@ describe('Core Router JWT normalization', () => {
     expect(jwt.generateJwt).not.toHaveBeenCalled();
   });
 
+  test('should refresh near-expiry query jwtToken and expose header', async () => {
+    const nowMs = 1700000000000;
+    const nowSeconds = Math.floor(nowMs / 1000);
+    const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(nowMs);
+    jwt.decodeJwt.mockImplementation((token) => {
+      if (token === 'query-token') {
+        return { id: 'user-1', platform: 'testCRM', exp: nowSeconds + 60 };
+      }
+      if (token === 'new-token') {
+        return { id: 'user-1', platform: 'testCRM', exp: nowSeconds + (14 * 24 * 60 * 60) };
+      }
+      return null;
+    });
+    jwt.generateJwt.mockReturnValue('new-token');
+    authCore.authValidation.mockResolvedValue({
+      successful: true,
+      returnMessage: { message: 'ok' },
+      failReason: null,
+      status: 200,
+    });
+    const app = buildApp();
+
+    const response = await request(app)
+      .get('/authValidation?jwtToken=query-token')
+      .set('Origin', 'https://example.com');
+
+    expect(response.status).toBe(200);
+    expect(response.headers['x-refreshed-jwt-token']).toBe('new-token');
+    expect(response.headers['access-control-expose-headers']).toContain('x-refreshed-jwt-token');
+    expect(jwt.generateJwt).toHaveBeenCalledWith({ id: 'user-1', platform: 'testCRM' });
+    expect(authCore.authValidation).toHaveBeenCalledWith({
+      platform: 'testCRM',
+      userId: 'user-1',
+    });
+    expect(jwt.decodeJwt).toHaveBeenCalledWith('new-token');
+    nowSpy.mockRestore();
+  });
+
+  test('should not rotate long-lived query jwtToken', async () => {
+    const nowMs = 1700000000000;
+    const nowSeconds = Math.floor(nowMs / 1000);
+    const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(nowMs);
+    jwt.decodeJwt.mockReturnValue({
+      id: 'user-1',
+      platform: 'testCRM',
+      exp: nowSeconds + (120 * 365 * 24 * 60 * 60),
+    });
+    authCore.authValidation.mockResolvedValue({
+      successful: true,
+      returnMessage: { message: 'ok' },
+      failReason: null,
+      status: 200,
+    });
+    const app = buildApp();
+
+    const response = await request(app).get('/authValidation?jwtToken=query-token');
+
+    expect(response.status).toBe(200);
+    expect(response.headers['x-refreshed-jwt-token']).toBeUndefined();
+    expect(jwt.generateJwt).not.toHaveBeenCalled();
+    nowSpy.mockRestore();
+  });
+
   test('should refresh near-expiry bearer token and expose header', async () => {
     const nowMs = 1700000000000;
     const nowSeconds = Math.floor(nowMs / 1000);
@@ -133,4 +197,105 @@ describe('Core Router JWT normalization', () => {
     });
   });
 });
+describe('Core Router implementedInterfaces contract', () => {
+  const originalUseCache = process.env.USE_CACHE;
+
+  beforeEach(() => {
+    connectorRegistry.connectors.clear();
+    connectorRegistry.manifests.clear();
+    connectorRegistry.platformInterfaces.clear();
+    delete process.env.USE_CACHE;
+  });
 
+  afterEach(() => {
+    connectorRegistry.connectors.clear();
+    connectorRegistry.manifests.clear();
+    connectorRegistry.platformInterfaces.clear();
+    if (originalUseCache === undefined) {
+      delete process.env.USE_CACHE;
+    } else {
+      process.env.USE_CACHE = originalUseCache;
+    }
+  });
+
+  test('returns client capability flags for an oauth platform', async () => {
+    connectorRegistry.registerConnector('contractCRM', {
+      getAuthType: jest.fn().mockReturnValue('oauth'),
+      getOauthInfo: jest.fn(),
+      getUserInfo: jest.fn(),
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn(),
+      createMessageLog: jest.fn(),
+      findContactWithName: jest.fn(),
+      getLicenseStatus: jest.fn(),
+    });
+    const app = buildApp();
+
+    const response = await request(app).get('/implementedInterfaces?platform=contractCRM');
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      getAuthType: true,
+      getOauthInfo: true,
+      getUserInfo: true,
+      createCallLog: true,
+      updateCallLog: true,
+      getCallLog: false,
+      createMessageLog: true,
+      updateMessageLog: false,
+      createContact: false,
+      findContact: false,
+      listAppointments: false,
+      createAppointment: false,
+      updateAppointment: false,
+      refreshAppointment: false,
+      confirmAppointment: false,
+      cancelAppointment: false,
+      unAuthorize: false,
+      upsertCallDisposition: false,
+      findContactWithName: true,
+      getUserList: false,
+      getLicenseStatus: true,
+      getLogFormatType: false,
+      refreshUserInfo: false,
+      cacheCallNote: false,
+    });
+    expect(response.body).not.toHaveProperty('getBasicAuth');
+  });
+
+  test('returns basic auth and cache flags for an apiKey platform', async () => {
+    process.env.USE_CACHE = 'true';
+    connectorRegistry.registerConnector('apiKeyCRM', {
+      getAuthType: jest.fn().mockReturnValue('apiKey'),
+      getBasicAuth: jest.fn(),
+      createCallLog: jest.fn(),
+      updateCallLog: jest.fn(),
+      updateMessageLog: jest.fn(),
+      refreshUserInfo: jest.fn(),
+    });
+    const app = buildApp();
+
+    const response = await request(app).get('/implementedInterfaces?platform=apiKeyCRM');
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual(expect.objectContaining({
+      getAuthType: true,
+      getBasicAuth: true,
+      createCallLog: true,
+      updateCallLog: true,
+      updateMessageLog: true,
+      refreshUserInfo: true,
+      cacheCallNote: true,
+    }));
+    expect(response.body).not.toHaveProperty('getOauthInfo');
+  });
+
+  test('rejects requests without a platform parameter', async () => {
+    const app = buildApp();
+
+    const response = await request(app).get('/implementedInterfaces');
+
+    expect(response.status).toBe(400);
+    expect(response.text).toBe('Please provide platform.');
+  });
+});

package/test/lib/analytics.test.js

@@ -0,0 +1,146 @@
+describe('analytics', () => {
+  let mixpanelInit;
+  let peopleSetOnce;
+  let track;
+  let parseUserAgent;
+
+  function loadAnalytics({ token } = {}) {
+    jest.resetModules();
+    peopleSetOnce = jest.fn();
+    track = jest.fn();
+    mixpanelInit = jest.fn(() => ({
+      people: {
+        set_once: peopleSetOnce
+      },
+      track
+    }));
+    parseUserAgent = jest.fn(() => ({
+      browser: { name: 'Chrome' },
+      os: { name: 'Windows' },
+      device: { type: 'desktop' }
+    }));
+
+    if (token) {
+      process.env.MIXPANEL_TOKEN = token;
+    } else {
+      delete process.env.MIXPANEL_TOKEN;
+    }
+
+    jest.doMock('mixpanel', () => ({
+      init: mixpanelInit
+    }));
+    jest.doMock('ua-parser-js', () => parseUserAgent);
+    jest.doMock('../../lib/logger', () => ({
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn()
+    }));
+
+    return {
+      analytics: require('../../lib/analytics'),
+      logger: require('../../lib/logger')
+    };
+  }
+
+  afterEach(() => {
+    delete process.env.MIXPANEL_TOKEN;
+    jest.dontMock('mixpanel');
+    jest.dontMock('ua-parser-js');
+    jest.dontMock('../../lib/logger');
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  test('does not initialize Mixpanel when token is missing and skips tracking without an initialized client', () => {
+    const { analytics } = loadAnalytics();
+
+    analytics.init();
+    analytics.track({
+      eventName: 'Call Log Created',
+      connectorName: 'salesforce',
+      extensionId: 'ext-1'
+    });
+
+    expect(mixpanelInit).not.toHaveBeenCalled();
+    expect(peopleSetOnce).not.toHaveBeenCalled();
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  test('skips tracking when extension id is missing', () => {
+    const { analytics } = loadAnalytics({ token: 'mixpanel-token' });
+
+    analytics.init();
+    analytics.track({
+      eventName: 'Call Log Created',
+      connectorName: 'salesforce',
+      accountId: 'account-1'
+    });
+
+    expect(mixpanelInit).toHaveBeenCalledWith('mixpanel-token');
+    expect(peopleSetOnce).not.toHaveBeenCalled();
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  test('tracks event properties, parsed user agent fields, extras, and default source', () => {
+    const { analytics, logger } = loadAnalytics({ token: 'mixpanel-token' });
+
+    analytics.init();
+    analytics.track({
+      eventName: 'Call Log Created',
+      interfaceName: 'desktop',
+      connectorName: 'salesforce',
+      accountId: 'account-1',
+      extensionId: 'ext-1',
+      success: true,
+      requestDuration: 123,
+      userAgent: 'Mozilla/5.0',
+      ip: '127.0.0.1',
+      author: 'unit-test',
+      extras: {
+        extraKey: 'extra-value'
+      }
+    });
+
+    expect(peopleSetOnce).toHaveBeenCalledWith('ext-1', {
+      version: expect.any(String),
+      appName: 'App Connect',
+      crmPlatform: 'salesforce'
+    });
+    expect(parseUserAgent).toHaveBeenCalledWith('Mozilla/5.0');
+    expect(track).toHaveBeenCalledWith('Call Log Created', expect.objectContaining({
+      distinct_id: 'ext-1',
+      interfaceName: 'desktop',
+      adapterName: 'salesforce',
+      rcAccountId: 'account-1',
+      extensionId: 'ext-1',
+      success: true,
+      requestDuration: 123,
+      collectedFrom: 'server',
+      appName: 'App Connect',
+      eventAddedVia: 'server',
+      $browser: 'Chrome',
+      $os: 'Windows',
+      $device: 'desktop',
+      ip: '127.0.0.1',
+      author: 'unit-test',
+      extraKey: 'extra-value'
+    }));
+    expect(logger.info).toHaveBeenCalledWith('Event: Call Log Created');
+  });
+
+  test('uses explicit eventAddedVia when provided', () => {
+    const { analytics } = loadAnalytics({ token: 'mixpanel-token' });
+
+    analytics.init();
+    analytics.track({
+      eventName: 'Disposition Saved',
+      connectorName: 'hubspot',
+      extensionId: 'ext-2',
+      eventAddedVia: 'browser'
+    });
+
+    expect(track).toHaveBeenCalledWith('Disposition Saved', expect.objectContaining({
+      eventAddedVia: 'browser'
+    }));
+  });
+});

package/test/lib/authSession.test.js

@@ -0,0 +1,173 @@
+const { CacheModel } = require('../../models/cacheModel');
+const {
+  createAuthSession,
+  getAuthSession,
+  updateAuthSession,
+} = require('../../lib/authSession');
+
+describe('authSession', () => {
+  const baseTime = new Date(Date.now() + (60 * 60 * 1000));
+
+  beforeEach(async () => {
+    await CacheModel.destroy({ where: {} });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('creates a pending auth session record with generated id and expiry', async () => {
+    jest.spyOn(Date, 'now').mockReturnValue(baseTime.getTime());
+
+    await createAuthSession('session-1', {
+      platform: 'clio',
+      hostname: 'https://example.clio.com',
+    });
+
+    const record = await CacheModel.findByPk('auth-session-session-1');
+    expect(record).not.toBeNull();
+    expect(record.userId).toBe('session-1');
+    expect(record.cacheKey).toBe('auth-session');
+    expect(record.status).toBe('pending');
+    expect(record.expiry.getTime()).toBe(baseTime.getTime() + (5 * 60 * 1000));
+    expect(record.data).toMatchObject({
+      platform: 'clio',
+      hostname: 'https://example.clio.com',
+    });
+    expect(new Date(record.data.createdAt).toString()).not.toBe('Invalid Date');
+
+    await expect(getAuthSession('session-1')).resolves.toMatchObject({
+      sessionId: 'session-1',
+      status: 'pending',
+      platform: 'clio',
+      hostname: 'https://example.clio.com',
+    });
+  });
+
+  test('creates with an empty hostname when hostname is missing', async () => {
+    await createAuthSession('session-no-hostname', {
+      platform: 'googleSheets',
+    });
+
+    const session = await getAuthSession('session-no-hostname');
+
+    expect(session).toMatchObject({
+      sessionId: 'session-no-hostname',
+      status: 'pending',
+      platform: 'googleSheets',
+      hostname: '',
+    });
+  });
+
+  test('resets an existing session record to pending with new session data', async () => {
+    await createAuthSession('retry-session', {
+      platform: 'clio',
+      hostname: 'old-host',
+    });
+    const existing = await CacheModel.findByPk('auth-session-retry-session');
+    await existing.update({
+      status: 'completed',
+      data: {
+        platform: 'clio',
+        hostname: 'old-host',
+        jwtToken: 'old-token',
+      },
+    });
+
+    await createAuthSession('retry-session', {
+      platform: 'bullhorn',
+    });
+
+    const record = await CacheModel.findByPk('auth-session-retry-session');
+    expect(record.status).toBe('pending');
+    expect(record.data).toMatchObject({
+      platform: 'bullhorn',
+      hostname: '',
+    });
+    expect(record.data.jwtToken).toBeUndefined();
+  });
+
+  test('returns null for missing sessions', async () => {
+    await expect(getAuthSession('missing-session')).resolves.toBeNull();
+  });
+
+  test('marks expired sessions as expired and returns current session data', async () => {
+    await CacheModel.create({
+      id: 'auth-session-expired-session',
+      cacheKey: 'auth-session',
+      userId: 'expired-session',
+      status: 'pending',
+      data: {
+        platform: 'pipedrive',
+        hostname: 'pipedrive-host',
+      },
+      expiry: new Date(Date.now() - 1000),
+    });
+
+    const session = await getAuthSession('expired-session');
+
+    expect(session).toEqual({
+      sessionId: 'expired-session',
+      status: 'expired',
+      platform: 'pipedrive',
+      hostname: 'pipedrive-host',
+    });
+    const record = await CacheModel.findByPk('auth-session-expired-session');
+    expect(record.status).toBe('expired');
+  });
+
+  test('updates an existing session by merging data and extending settled expiry', async () => {
+    jest.spyOn(Date, 'now').mockReturnValue(baseTime.getTime());
+    await createAuthSession('update-session', {
+      platform: 'netsuite',
+      hostname: 'netsuite-host',
+    });
+    jest.spyOn(Date, 'now').mockReturnValue(baseTime.getTime() + 1000);
+
+    await updateAuthSession('update-session', {
+      status: 'completed',
+      jwtToken: 'jwt-token',
+      rcExtensionId: 'extension-1',
+    });
+
+    const record = await CacheModel.findByPk('auth-session-update-session');
+    expect(record.status).toBe('completed');
+    expect(record.expiry.getTime()).toBe(baseTime.getTime() + 1000 + (15 * 60 * 1000));
+    expect(record.data).toMatchObject({
+      platform: 'netsuite',
+      hostname: 'netsuite-host',
+      status: 'completed',
+      jwtToken: 'jwt-token',
+      rcExtensionId: 'extension-1',
+    });
+    expect(new Date(record.data.updatedAt).toString()).not.toBe('Invalid Date');
+  });
+
+  test('keeps pending expiry when update does not settle the session', async () => {
+    jest.spyOn(Date, 'now').mockReturnValue(baseTime.getTime());
+    await createAuthSession('pending-session', {
+      platform: 'redtail',
+    });
+    jest.spyOn(Date, 'now').mockReturnValue(baseTime.getTime() + 2000);
+
+    await updateAuthSession('pending-session', {
+      hostname: 'new-host',
+    });
+
+    const record = await CacheModel.findByPk('auth-session-pending-session');
+    expect(record.status).toBe('pending');
+    expect(record.expiry.getTime()).toBe(baseTime.getTime() + 2000 + (5 * 60 * 1000));
+    expect(record.data).toMatchObject({
+      platform: 'redtail',
+      hostname: 'new-host',
+    });
+  });
+
+  test('does nothing when updating a missing session', async () => {
+    await expect(updateAuthSession('missing-session', {
+      status: 'completed',
+    })).resolves.toBeUndefined();
+
+    await expect(CacheModel.findByPk('auth-session-missing-session')).resolves.toBeNull();
+  });
+});

package/test/lib/encode.test.js

@@ -0,0 +1,59 @@
+const { decoded, encode } = require('../../lib/encode');
+
+describe('encode', () => {
+  const originalSecret = process.env.APP_SERVER_SECRET_KEY;
+
+  afterEach(() => {
+    if (originalSecret === undefined) {
+      delete process.env.APP_SERVER_SECRET_KEY;
+    } else {
+      process.env.APP_SERVER_SECRET_KEY = originalSecret;
+    }
+  });
+
+  test('encodes and decodes a string with a 32-character secret', () => {
+    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012';
+
+    const encrypted = encode('sensitive token value');
+
+    expect(encrypted).toMatch(/^[0-9a-f]+$/);
+    expect(encrypted).not.toBe('sensitive token value');
+    expect(decoded(encrypted)).toBe('sensitive token value');
+  });
+
+  test('throws a deterministic error when secret is missing', () => {
+    delete process.env.APP_SERVER_SECRET_KEY;
+
+    expect(() => encode('data')).toThrow('APP_SERVER_SECRET_KEY is not defined');
+    expect(() => decoded('abcd')).toThrow('APP_SERVER_SECRET_KEY is not defined');
+  });
+
+  test('pads short secrets with spaces to 32 bytes', () => {
+    process.env.APP_SERVER_SECRET_KEY = 'short-secret';
+    const encryptedWithShortSecret = encode('payload');
+
+    process.env.APP_SERVER_SECRET_KEY = 'short-secret'.padEnd(32, ' ');
+    const encryptedWithPaddedSecret = encode('payload');
+
+    expect(encryptedWithShortSecret).toBe(encryptedWithPaddedSecret);
+    expect(decoded(encryptedWithShortSecret)).toBe('payload');
+  });
+
+  test('truncates long secrets to 32 bytes', () => {
+    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012-first-suffix';
+    const encryptedWithLongSecret = encode('payload');
+
+    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012-second-suffix';
+    const encryptedWithSamePrefix = encode('payload');
+
+    expect(encryptedWithLongSecret).toBe(encryptedWithSamePrefix);
+    expect(decoded(encryptedWithLongSecret)).toBe('payload');
+  });
+
+  test('throws when encrypted input is not valid hex ciphertext', () => {
+    process.env.APP_SERVER_SECRET_KEY = '12345678901234567890123456789012';
+
+    expect(() => decoded('not-valid-ciphertext')).toThrow();
+  });
+});
+