@app-connect/core 1.7.1 → 1.7.4

package/test/connector/proxy/engine.test.js

@@ -0,0 +1,93 @@
+const path = require('path');
+
+jest.mock('axios', () => jest.fn());
+const axios = require('axios');
+
+const {
+  renderTemplateString,
+  renderDeep,
+  joinUrl,
+  performRequest,
+} = require('../../../connector/proxy/engine');
+
+describe('proxy engine utilities', () => {
+  beforeEach(() => {
+    axios.mockReset();
+  });
+
+  test('renderTemplateString handles full and partial templates', () => {
+    const context = { a: { b: 123 }, name: 'Alice' };
+    expect(renderTemplateString('{{a.b}}', context)).toBe(123);
+    expect(renderTemplateString('Hello {{name}}', context)).toBe('Hello Alice');
+    expect(renderTemplateString('Missing {{x.y}} here', context)).toBe('Missing  here');
+  });
+
+  test('renderDeep renders nested objects and arrays', () => {
+    const context = { id: 42, name: 'Alice', items: ['x', 'y'] };
+    const input = {
+      url: '/users/{{id}}',
+      body: { name: '{{name}}', tags: ['a', '{{items.1}}'] },
+    };
+    const out = renderDeep(input, context);
+    expect(out.url).toBe('/users/42');
+    expect(out.body.name).toBe('Alice');
+    expect(out.body.tags).toEqual(['a', 'y']);
+  });
+
+  test('joinUrl joins base and path and preserves absolute urls', () => {
+    expect(joinUrl('https://api.example.com', '/v1/items')).toBe('https://api.example.com/v1/items');
+    expect(joinUrl('https://api.example.com/', 'v1/items')).toBe('https://api.example.com/v1/items');
+    expect(joinUrl('', 'https://full.example.com/x')).toBe('https://full.example.com/x');
+  });
+
+  test('performRequest composes url, headers, params, body and auth', async () => {
+    axios.mockResolvedValue({ data: { ok: true } });
+    const config = {
+      secretKey: 'shh-key',
+      auth: {
+        type: 'apiKey',
+        scheme: 'Basic',
+        credentialTemplate: '{{apiKey}}',
+        encode: 'base64',
+        headerName: 'Authorization'
+      },
+      requestDefaults: {
+        baseUrl: 'https://api.example.com',
+        timeoutSeconds: 10,
+        defaultHeaders: { Accept: 'application/json', 'X-Secret-Key': '{{secretKey}}' }
+      },
+      operations: {
+        createThing: {
+          method: 'POST',
+          url: '/things/{{thingId}}',
+          headers: { 'Content-Type': 'application/json' },
+          query: { search: '{{q}}' },
+          body: { id: '{{thingId}}', name: '{{name}}' }
+        }
+      }
+    };
+    const user = { accessToken: 'token-123' };
+    await performRequest({
+      config,
+      opName: 'createThing',
+      inputs: { thingId: 7, name: 'Widget', q: 'alpha' },
+      user,
+      authHeader: undefined
+    });
+
+    expect(axios).toHaveBeenCalledTimes(1);
+    const args = axios.mock.calls[0][0];
+    expect(args.url).toBe('https://api.example.com/things/7');
+    expect(args.method).toBe('POST');
+    expect(args.params).toEqual({ search: 'alpha' });
+    expect(args.data).toEqual({ id: 7, name: 'Widget' });
+    expect(args.timeout).toBe(10000);
+    expect(args.headers.Accept).toBe('application/json');
+    expect(args.headers['Content-Type']).toBe('application/json');
+    expect(args.headers['X-Secret-Key']).toBe('shh-key');
+    // Basic base64('token-123')
+    expect(args.headers.Authorization).toMatch(/^Basic /);
+  });
+});
+
+

package/test/connector/proxy/index.test.js

@@ -0,0 +1,279 @@
+jest.mock('axios', () => jest.fn());
+jest.mock('../../../models/dynamo/connectorSchema', () => ({
+  Connector: { getProxyConfig: jest.fn() }
+}));
+jest.mock('awesome-phonenumber', () => ({
+  parsePhoneNumber: jest.fn().mockReturnValue({})
+}));
+jest.mock('../../../models/userModel', () => ({
+  UserModel: { findByPk: jest.fn() }
+}));
+
+const axios = require('axios');
+const { Connector } = require('../../../models/dynamo/connectorSchema');
+const { UserModel } = require('../../../models/userModel');
+const proxy = require('../../../connector/proxy/index');
+const sampleConfig = require('./sample.json');
+
+describe('proxy connector (high-level)', () => {
+  beforeEach(() => {
+    axios.mockReset();
+  });
+
+  test('createCallLog returns mapped logId using provided proxyConfig', async () => {
+    // Response matching mapping: response.activity.id (engine wraps as { response: response.data })
+    axios.mockResolvedValue({ data: { activity: { id: 'A-100' } } });
+
+    const user = { accessToken: 't-123', platformAdditionalInfo: { proxyId: 'p1' } };
+    const contactInfo = { id: 'c-1', name: 'Alice' };
+    const callLog = { direction: 'Outbound', startTime: Date.now(), duration: 60 };
+
+    const res = await proxy.createCallLog({
+      user,
+      contactInfo,
+      authHeader: 'Basic abc',
+      callLog,
+      note: 'hello',
+      additionalSubmission: {},
+      aiNote: '',
+      transcript: '',
+      hashedAccountId: 'h1',
+      isFromSSCL: false,
+      composedLogDetails: 'details',
+      proxyConfig: sampleConfig
+    });
+
+    expect(res.logId).toBe('A-100');
+    expect(res.returnMessage.messageType).toBe('success');
+    expect(axios).toHaveBeenCalledTimes(1);
+    const args = axios.mock.calls[0][0];
+    expect(args.method).toBe('POST');
+    expect(args.url).toMatch(/\/activities$/);
+    expect(args.headers['Content-Type']).toBe('application/json');
+    expect(args.data.subject).toMatch(/Call/);
+    expect(args.data.linked_contacts[0].contact_id).toBe('c-1');
+  });
+
+  test('getCallLog maps subject, note and fullBody', async () => {
+    axios.mockResolvedValue({ data: { activity: { subject: 'S', note: 'N', description: 'D' } } });
+
+    const out = await proxy.getCallLog({
+      user: { accessToken: 't-123', platformAdditionalInfo: { proxyId: 'p1' } },
+      callLogId: '123',
+      contactId: 'c-1',
+      authHeader: 'x',
+      proxyConfig: sampleConfig
+    });
+
+    expect(out.callLogInfo.subject).toBe('S');
+    expect(out.callLogInfo.note).toBe('N');
+    expect(out.callLogInfo.fullBody).toBe('D');
+    expect(out.callLogInfo.fullLogResponse).toBeDefined();
+  });
+
+  test('updateCallLog performs PUT and returns success message', async () => {
+    axios.mockResolvedValue({ data: { ok: true } });
+
+    const start = new Date('2020-01-01T00:00:00Z');
+    const res = await proxy.updateCallLog({
+      user: { accessToken: 't-123', platformAdditionalInfo: { proxyId: 'p1' } },
+      existingCallLog: { thirdPartyLogId: '77' },
+      authHeader: 'x',
+      recordingLink: '',
+      recordingDownloadLink: '',
+      subject: 'Subj',
+      note: 'Note',
+      startTime: start,
+      duration: 90,
+      result: 'Completed',
+      aiNote: '',
+      transcript: '',
+      legs: [],
+      additionalSubmission: {},
+      composedLogDetails: 'Body',
+      existingCallLogDetails: {},
+      hashedAccountId: 'h',
+      isFromSSCL: false,
+      proxyConfig: sampleConfig
+    });
+
+    expect(res.returnMessage.message).toMatch(/updated/i);
+    const args = axios.mock.calls[0][0];
+    expect(args.method).toBe('PUT');
+    expect(args.url).toMatch(/\/activities\/77$/);
+    expect(args.data.subject).toBe('Subj');
+    expect(args.data.end_date).toBeDefined();
+  });
+
+  test('getLogFormatType returns meta.logFormat or custom', () => {
+    expect(proxy.getLogFormatType('x', sampleConfig)).toBe('text/plain');
+    expect(proxy.getLogFormatType('x', null)).toBe('custom');
+  });
+});
+
+describe('proxy connector - more coverage', () => {
+  beforeEach(() => {
+    axios.mockReset();
+    Connector.getProxyConfig.mockReset();
+  });
+
+  test('getAuthType returns apiKey', async () => {
+    expect(await proxy.getAuthType()).toBe('apiKey');
+  });
+
+  test('getBasicAuth encodes apiKey with colon', () => {
+    const token = proxy.getBasicAuth({ apiKey: 'abc' });
+    expect(token).toBe(Buffer.from('abc:').toString('base64'));
+  });
+
+  test('getUserInfo maps id/name/message/platformAdditionalInfo', async () => {
+    const cfg = JSON.parse(JSON.stringify(sampleConfig));
+    delete cfg.auth; // ensure provided authHeader is used
+    Connector.getProxyConfig.mockResolvedValue(cfg);
+    axios.mockResolvedValue({ data: { user: { username: 'u1', role: 'admin' }, message: 'OK' } });
+
+    const res = await proxy.getUserInfo({
+      authHeader: 'Basic t',
+      hostname: 'host',
+      additionalInfo: { foo: 'bar' },
+      platform: 'test',
+      apiKey: 'k',
+      proxyId: 'p1'
+    });
+
+    expect(res.successful).toBe(true);
+    expect(res.platformUserInfo.id).toBe('u1-test');
+    expect(res.platformUserInfo.name).toBe('u1');
+    expect(res.returnMessage.message).toBe('OK');
+    expect(res.platformUserInfo.platformAdditionalInfo.userResponse).toEqual({ username: 'u1', role: 'admin' });
+  });
+
+  test('findContact maps list items', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig);
+    axios.mockResolvedValue({ data: { contacts: [ { id: 'c1', name: 'Alice', type: 'Contact', phone: '+1' } ] } });
+
+    const out = await proxy.findContact({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      authHeader: 'x',
+      phoneNumber: '+1',
+      overridingFormat: '',
+      isExtension: false
+    });
+
+    expect(out.successful).toBe(true);
+    expect(out.matchedContactInfo.length).toBe(1);
+    expect(out.matchedContactInfo[0].id).toBe('c1');
+  });
+
+  test('createContact maps object response', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig);
+    axios.mockResolvedValue({ data: { id: 'c2', name: 'Bob', type: 'Lead' } });
+
+    const res = await proxy.createContact({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      authHeader: 'x',
+      phoneNumber: '+1',
+      newContactName: 'Bob',
+      newContactType: 'Lead',
+      additionalSubmission: {}
+    });
+
+    expect(res.contactInfo).toEqual({ id: 'c2', name: 'Bob', type: 'Lead' });
+    expect(res.returnMessage.messageType).toBe('success');
+  });
+
+  test('createMessageLog maps idPath and updateMessageLog returns success', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig);
+    axios.mockResolvedValueOnce({ data: { activity: { id: 'M1' } } });
+
+    const create = await proxy.createMessageLog({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      contactInfo: { id: 'c1', name: 'Alice' },
+      authHeader: 'x',
+      message: { subject: 'S', direction: 'Outbound', from: { phoneNumber: '+1' }, creationTime: Date.now() },
+      additionalSubmission: {},
+      recordingLink: '',
+      faxDocLink: '',
+      faxDownloadLink: '',
+      imageLink: '',
+      videoLink: ''
+    });
+    expect(create.logId).toBe('M1');
+
+    axios.mockResolvedValueOnce({ data: { ok: true } });
+    const update = await proxy.updateMessageLog({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      contactInfo: { id: 'c1', name: 'Alice' },
+      existingMessageLog: { thirdPartyLogId: 'M1' },
+      message: { subject: 'S', direction: 'Outbound', from: { phoneNumber: '+1' }, creationTime: Date.now() },
+      authHeader: 'x',
+      additionalSubmission: {},
+      imageLink: '',
+      videoLink: ''
+    });
+    expect(update.returnMessage.message).toMatch(/updated/i);
+    const args2 = axios.mock.calls[1][0];
+    expect(args2.url).toMatch(/\/activities\/M1$/);
+  });
+
+  test('upsertCallDisposition returns Not supported when op missing', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig);
+    const res = await proxy.upsertCallDisposition({
+      user: { accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } },
+      existingCallLog: { thirdPartyLogId: 'L1' },
+      authHeader: 'x',
+      dispositions: []
+    });
+    expect(res.returnMessage.message).toMatch(/Not supported/);
+  });
+
+  test('getLicenseStatus maps values with custom config', async () => {
+    const licenseConfig = {
+      requestDefaults: { baseUrl: 'https://api.example.com' },
+      operations: {
+        getLicenseStatus: {
+          method: 'GET',
+          url: '/license/{{userId}}',
+          responseMapping: {
+            isLicenseValidPath: 'body.valid',
+            licenseStatusPath: 'body.status',
+            licenseStatusDescriptionPath: 'body.desc'
+          }
+        }
+      }
+    };
+    Connector.getProxyConfig.mockResolvedValue(licenseConfig);
+    axios.mockResolvedValue({ data: { valid: true, status: 'Pro', desc: 'All good' } });
+    UserModel.findByPk.mockResolvedValue({ id: 'u1', accessToken: 't', platformAdditionalInfo: { proxyId: 'p1' } });
+
+    const s = await proxy.getLicenseStatus({ userId: 'u1', platform: 'x' });
+    expect(s.isLicenseValid).toBe(true);
+    expect(s.licenseStatus).toBe('Pro');
+    expect(s.licenseStatusDescription).toBe('All good');
+  });
+
+  test('unAuthorize without custom op clears tokens and saves user', async () => {
+    Connector.getProxyConfig.mockResolvedValue(sampleConfig); // no unAuthorize op
+    const user = { accessToken: 't', refreshToken: 'r', save: jest.fn(), platformAdditionalInfo: { proxyId: 'p1' } };
+    const out = await proxy.unAuthorize({ user });
+    expect(user.accessToken).toBe('');
+    expect(user.refreshToken).toBe('');
+    expect(user.save).toHaveBeenCalled();
+    expect(out.returnMessage.messageType).toBe('success');
+  });
+
+  test('unAuthorize with custom op triggers request then clears tokens', async () => {
+    const cfg = {
+      requestDefaults: { baseUrl: 'https://api.example.com' },
+      operations: { unAuthorize: { method: 'POST', url: '/logout' } }
+    };
+    Connector.getProxyConfig.mockResolvedValue(cfg);
+    axios.mockResolvedValue({ data: { ok: true } });
+    const user = { accessToken: 't', refreshToken: 'r', save: jest.fn(), platformAdditionalInfo: { proxyId: 'p1' } };
+    const out = await proxy.unAuthorize({ user });
+    expect(axios).toHaveBeenCalledTimes(1);
+    expect(out.returnMessage.message).toMatch(/Logged out/);
+    expect(user.accessToken).toBe('');
+  });
+});
+

package/test/connector/proxy/sample.json

@@ -0,0 +1,161 @@
+{
+  "meta": {
+    "name": "",
+    "displayName": "",
+    "logFormat": "text/plain"
+  },
+  "auth": {
+    "type": "apiKey",
+    "scheme": "Basic",
+    "credentialTemplate": "{{apiKey}}",
+    "encode": "base64",
+    "headerName": "Authorization"
+  },
+  "requestDefaults": {
+    "baseUrl": "",
+    "timeoutSeconds": 30,
+    "defaultHeaders": {
+      "Accept": "application/json",
+      "X-Secret-Key": "{{secretKey}}"
+    }
+  },
+  "operations": {
+    "getUserInfo": {
+      "method": "GET",
+      "url": "/authentication",
+      "responseMapping": {
+        "type": "object",
+        "idPath": "body.user.username",
+        "namePath": "body.user.username",
+        "messagePath": "body.message",
+        "platformAdditionalInfoPaths": {
+          "userResponse": "body.user"
+        }
+      }
+    },
+    "findContact": {
+      "method": "GET",
+      "url": "/contacts",
+      "query": {
+        "phone": "{{phoneNumber}}"
+      },
+      "responseMapping": {
+        "type": "list",
+        "listPath": "body.contacts",
+        "item": {
+          "idPath": "id",
+          "namePath": "name",
+          "typePath": "",
+          "phonePath": "",
+          "additionalInfoPath": ""
+        }
+      }
+    },
+    "createContact": {
+      "method": "POST",
+      "url": "/contacts",
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "body": {
+        "name": "{{newContactName}}",
+        "type": "{{newContactType}}",
+        "phone": "{{phoneNumber}}"
+      },
+      "responseMapping": {
+        "type": "object",
+        "idPath": "body.id",
+        "namePath": "body.name",
+        "typePath": "body.type"
+      }
+    },
+    "createCallLog": {
+      "method": "POST",
+      "url": "/activities",
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "body": {
+        "subject": "{{subject}}",
+        "description": "{{composedLogDetails}}",
+        "start_date": "{{startTime}}",
+        "end_date": "{{endTime}}",
+        "activity_code_id": 3,
+        "repeats": "never",
+        "linked_contacts": [
+          { "contact_id": "{{contactInfo.id}}" }
+        ]
+      },
+      "responseMapping": {
+        "type": "object",
+        "idPath": "body.activity.id"
+      }
+    },
+    "updateCallLog": {
+      "method": "PUT",
+      "url": "/activities/{{thirdPartyLogId}}",
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "body": {
+        "subject": "{{subject}}",
+        "description": "{{composedLogDetails}}",
+        "start_date": "{{startTime}}",
+        "end_date": "{{endTime}}"
+      }
+    },
+    "getCallLog": {
+      "method": "GET",
+      "url": "/activities/{{thirdPartyLogId}}",
+      "headers": {
+        "include": "linked_contacts"
+      },
+      "responseMapping": {
+        "type": "object",
+        "subjectPath": "body.activity.subject",
+        "notePath": "body.activity.note",
+        "fullBodyPath": "body.activity.description"
+      }
+    },
+    "createMessageLog": {
+      "method": "POST",
+      "url": "/activities",
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "body": {
+        "subject": "Message with {{contactInfo.name}}",
+        "description": "Subject: {{message.subject}}\nDirection: {{message.direction}}\n phoneNumber: {{message.from.phoneNumber}}\nRecording link: {{recordingLink}}\n",
+        "start_date": "{{creationTime}}",
+        "end_date": "{{creationTime}}",
+        "activity_code_id": 3,
+        "repeats": "never",
+        "linked_contacts": [
+          { "contact_id": "{{contactInfo.id}}" }
+        ]
+      },
+      "responseMapping": {
+        "type": "object",
+        "idPath": "body.activity.id"
+      }
+    },
+    "updateMessageLog": {
+      "method": "PUT",
+      "url": "/activities/{{thirdPartyLogId}}",
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "body": {
+        "subject": "Message with {{contactInfo.name}}",
+        "description": "Subject: {{message.subject}}\nDirection: {{message.direction}}\nRecording link: {{recordingLink}}\n",
+        "start_date": "{{creationTime}}",
+        "end_date": "{{creationTime}}",
+        "activity_code_id": 3,
+        "repeats": "never",
+        "linked_contacts": [
+          { "contact_id": "{{contactInfo.id}}" }
+        ]
+      }
+    }
+  }
+}

package/test/{adapter → connector}/registry.test.js

@@ -173,7 +173,7 @@ describe('ConnectorRegistry Interface Registration with Composition', () => {
     expect(connectorRegistry.hasPlatformInterface('testPlatform', 'testInterface')).toBe(false);
   });
 
-  test('should get connector capabilities correctly', () => {
+  test('should get connector capabilities correctly', async () => {
     const mockInterface = jest.fn();
     const mockConnector = {
       getAuthType: () => 'apiKey',
@@ -184,7 +184,7 @@ describe('ConnectorRegistry Interface Registration with Composition', () => {
     connectorRegistry.registerConnectorInterface('testPlatform', 'customMethod', mockInterface);
     connectorRegistry.registerConnector('testPlatform', mockConnector);
     
-    const capabilities = connectorRegistry.getConnectorCapabilities('testPlatform');
+    const capabilities = await connectorRegistry.getConnectorCapabilities('testPlatform');
     
     expect(capabilities.platform).toBe('testPlatform');
     expect(capabilities.originalMethods).toContain('getAuthType');
@@ -248,7 +248,7 @@ describe('ConnectorRegistry Interface Registration with Composition', () => {
     }).toThrow('Connector not found for platform: nonExistentPlatform');
   });
 
-  test('should handle mixed scenarios correctly', () => {
+  test('should handle mixed scenarios correctly', async () => {
     // Scenario 1: Only interfaces, no connector
     connectorRegistry.registerConnectorInterface('mixedPlatform', 'interfaceMethod', jest.fn());
     const interfaceOnly = connectorRegistry.getConnector('mixedPlatform');
@@ -266,6 +266,6 @@ describe('ConnectorRegistry Interface Registration with Composition', () => {
     const composedConnector = connectorRegistry.getConnector('mixedPlatform');
     expect(composedConnector.interfaceMethod).toBeDefined();
     expect(composedConnector.getAuthType).toBeDefined();
-    expect(composedConnector.getAuthType()).toBe('apiKey');
+    expect(await composedConnector.getAuthType()).toBe('apiKey');
   });
 }); 

package/test/handlers/auth.test.js

@@ -57,7 +57,9 @@ describe('Auth Handler', () => {
         authHeader: 'Basic dGVzdC1hcGkta2V5Og==',
         hostname: 'test.example.com',
         additionalInfo: {},
-        apiKey: 'test-api-key'
+        apiKey: 'test-api-key',
+        platform: 'testCRM',
+        proxyId: undefined
       });
     });