@app-connect/core 1.7.0 → 1.7.3

package/index.js

@@ -18,6 +18,7 @@ const adminCore = require('./handlers/admin');
 const userCore = require('./handlers/user');
 const dispositionCore = require('./handlers/disposition');
 const mock = require('./connector/mock');
+const proxyConnector = require('./connector/proxy');
 const releaseNotes = require('./releaseNotes.json');
 const analytics = require('./lib/analytics');
 const util = require('./lib/util');
@@ -124,6 +125,48 @@ function createCoreRouter() {
         res.send(`OK`);
     });
 
+    router.get('/implementedInterfaces', (req, res) => {
+        try {
+            const platform = req.query.platform;
+            if (platform) {
+                const platformModule = connectorRegistry.getConnector(platform);
+                const result = {};
+                const authType = platformModule.getAuthType();
+                result.getAuthType = !!platformModule.getAuthType;
+                switch(authType){
+                    case 'oauth':
+                        result.getOauthInfo = !!platformModule.getOauthInfo;
+                        break;
+                    case 'apiKey':
+                        result.getBasicAuth = !!platformModule.getBasicAuth;
+                        break;
+                }
+                result.getUserInfo = !!platformModule.getUserInfo;
+                result.createCallLog = !!platformModule.createCallLog;
+                result.updateCallLog = !!platformModule.updateCallLog;
+                result.getCallLog = !!platformModule.getCallLog;
+                result.createMessageLog = !!platformModule.createMessageLog;
+                result.updateMessageLog = !!platformModule.updateMessageLog;
+                result.createContact = !!platformModule.createContact;
+                result.findContact = !!platformModule.findContact;
+                result.unAuthorize = !!platformModule.unAuthorize;
+                result.upsertCallDisposition = !!platformModule.upsertCallDisposition;
+                result.findContactWithName = !!platformModule.findContactWithName;
+                result.getUserList = !!platformModule.getUserList;
+                result.getLicenseStatus = !!platformModule.getLicenseStatus;
+                result.getLogFormatType = !!platformModule.getLogFormatType;
+                res.status(200).send(result);
+            }
+            else {
+                res.status(400).send('Please provide platform.');
+                return;
+            }
+        }
+        catch (e) {
+            res.status(400).send(e);
+        }
+    });
+
     router.get('/licenseStatus', async (req, res) => {
         const requestStartTime = new Date().getTime();
         let platformName = null;
@@ -647,7 +690,8 @@ function createCoreRouter() {
                 callbackUri: req.query.callbackUri,
                 apiUrl: req.query.apiUrl,
                 username: req.query.username,
-                query: req.query
+                query: req.query,
+                proxyId: req.query.proxyId
             });
             if (userInfo) {
                 const jwtToken = jwt.generateJwt({
@@ -692,6 +736,7 @@ function createCoreRouter() {
             platformName = platform;
             const apiKey = req.body.apiKey;
             const hostname = req.body.hostname;
+            const proxyId = req.body.proxyId;
             const additionalInfo = req.body.additionalInfo;
             if (!platform) {
                 throw 'Missing platform name';
@@ -699,7 +744,7 @@ function createCoreRouter() {
             if (!apiKey) {
                 throw 'Missing api key';
             }
-            const { userInfo, returnMessage } = await authCore.onApiKeyLogin({ platform, hostname, apiKey, additionalInfo });
+            const { userInfo, returnMessage } = await authCore.onApiKeyLogin({ platform, hostname, apiKey, proxyId, additionalInfo });
             if (userInfo) {
                 const jwtToken = jwt.generateJwt({
                     id: userInfo.id.toString(),
@@ -1626,3 +1671,4 @@ exports.createCoreMiddleware = createCoreMiddleware;
 exports.createCoreApp = createCoreApp;
 exports.initializeCore = initializeCore;
 exports.connectorRegistry = connectorRegistry;
+exports.proxyConnector = proxyConnector;

package/lib/analytics.js

@@ -33,7 +33,7 @@ exports.track = function track({ eventName, interfaceName, connectorName, accoun
     mixpanel.track(eventName, {
         distinct_id: extensionId,
         interfaceName,
-        connectorName,
+        adapterName: connectorName,
         rcAccountId: accountId,
         extensionId,
         success,

package/lib/callLogComposer.js

@@ -41,6 +41,11 @@ async function composeCallLog(params) {
         startTime,
         duration,
         result,
+        ringSenseTranscript,
+        ringSenseSummary,
+        ringSenseAIScore,
+        ringSenseBulletedSummary,
+        ringSenseLink,
         platform
     } = params;
 
@@ -62,14 +67,18 @@ async function composeCallLog(params) {
     }
 
     if (userSettings?.addRingCentralUserName?.value) {
-        const ringcentralUsername = (callLog.direction === 'Inbound' ? callLog?.to?.name : callLog?.from?.name) ?? '(pending...)';
-        body = upsertRingCentralUserName({ body, userName: ringcentralUsername, logFormat });
+        const ringcentralUsername = (callLog.direction === 'Inbound' ? callLog?.to?.name : callLog?.from?.name) ?? null;
+        if (ringcentralUsername) {
+            body = upsertRingCentralUserName({ body, userName: ringcentralUsername, logFormat });
+        }
     }
 
-    const ringcentralNumber = callLog.direction === 'Inbound' ? callLog?.to?.phoneNumber : callLog?.from?.phoneNumber;
-    if (ringcentralNumber && (userSettings?.addRingCentralNumber?.value ?? false)) {
-        const ringcentralExtensionNumber = callLog.direction === 'Inbound' ? callLog?.from?.extensionNumber : callLog?.to?.extensionNumber;
-        body = upsertRingCentralNumberAndExtension({ body, number: ringcentralNumber, extension: ringcentralExtensionNumber ?? '', logFormat });
+    if (userSettings?.addRingCentralNumber?.value ?? false) {
+        const ringcentralNumber = callLog.direction === 'Inbound' ? callLog?.to?.phoneNumber : callLog?.from?.phoneNumber;
+        if (ringcentralNumber) {
+            const ringcentralExtensionNumber = callLog.direction === 'Inbound' ? callLog?.from?.extensionNumber : callLog?.to?.extensionNumber;
+            body = upsertRingCentralNumberAndExtension({ body, number: ringcentralNumber, extension: ringcentralExtensionNumber ?? '', logFormat });
+        }
     }
 
     if (subject && (userSettings?.addCallLogSubject?.value ?? true)) {
@@ -115,6 +124,26 @@ async function composeCallLog(params) {
         body = upsertTranscript({ body, transcript, logFormat });
     }
 
+    if (ringSenseTranscript && (userSettings?.addCallLogRingSenseRecordingTranscript?.value ?? true)) {
+        body = upsertRingSenseTranscript({ body, transcript: ringSenseTranscript, logFormat });
+    }
+
+    if (ringSenseSummary && (userSettings?.addCallLogRingSenseRecordingSummary?.value ?? true)) {
+        body = upsertRingSenseSummary({ body, summary: ringSenseSummary, logFormat });
+    }
+
+    if (ringSenseAIScore && (userSettings?.addCallLogRingSenseRecordingAIScore?.value ?? true)) {
+        body = upsertRingSenseAIScore({ body, score: ringSenseAIScore, logFormat });
+    }
+
+    if (ringSenseBulletedSummary && (userSettings?.addCallLogRingSenseRecordingBulletedSummary?.value ?? true)) {
+        body = upsertRingSenseBulletedSummary({ body, summary: ringSenseBulletedSummary, logFormat });
+    }
+
+    if (ringSenseLink && (userSettings?.addCallLogRingSenseRecordingLink?.value ?? true)) {
+        body = upsertRingSenseLink({ body, link: ringSenseLink, logFormat });
+    }
+
     if (callLog?.legs && (userSettings?.addCallLogLegs?.value ?? true)) {
         body = upsertLegs({ body, legs: callLog.legs, logFormat });
     }
@@ -382,7 +411,7 @@ function upsertCallDuration({ body, duration, logFormat }) {
         // More flexible regex that handles both with and without newlines
         const durationRegex = /- Duration: ([^\n-]+)(?=\n-|\n|$)/;
         if (durationRegex.test(result)) {
-            result = result.replace(durationRegex, `- Duration: ${formattedDuration}\n`);
+            result = result.replace(durationRegex, `- Duration: ${formattedDuration}`);
         } else {
             result += `- Duration: ${formattedDuration}\n`;
         }
@@ -415,7 +444,7 @@ function upsertCallResult({ body, result, logFormat }) {
         // More flexible regex that handles both with and without newlines
         const resultRegex = /- Result: ([^\n-]+)(?=\n-|\n|$)/;
         if (resultRegex.test(bodyResult)) {
-            bodyResult = bodyResult.replace(resultRegex, `- Result: ${result}\n`);
+            bodyResult = bodyResult.replace(resultRegex, `- Result: ${result}`);
         } else {
             bodyResult += `- Result: ${result}\n`;
         }
@@ -429,8 +458,8 @@ function upsertCallRecording({ body, recordingLink, logFormat }) {
     let result = body;
 
     if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
-        // More flexible regex that handles both <li> wrapped and unwrapped content
-        const recordingLinkRegex = /(?:<li>)?<b>Call recording link<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
+		// More flexible regex that handles both <li> wrapped and unwrapped content, and existing <a> anchors
+		const recordingLinkRegex = /(?:<li>)?<b>Call recording link<\/b>:\s*(?:<a[^>]*>[^<]*<\/a>|[^<]+)(?:<\/li>|(?=<|$))/i;
         if (recordingLink) {
             if (recordingLinkRegex.test(result)) {
                 if (recordingLink.startsWith('http')) {
@@ -615,6 +644,158 @@ function upsertLegs({ body, legs, logFormat }) {
     return result;
 }
 
+function upsertRingSenseTranscript({ body, transcript, logFormat }) {
+    if (!transcript) return body;
+
+    let result = body;
+    const clearedTranscript = transcript.replace(/\n+$/, '');
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
+        const formattedTranscript = clearedTranscript.replace(/(?:\r\n|\r|\n)/g, '<br>');
+        const transcriptRegex = /<div><b>RingSense transcript<\/b><br>(.+?)<\/div>/;
+        if (transcriptRegex.test(result)) {
+            result = result.replace(transcriptRegex, `<div><b>RingSense transcript</b><br>${formattedTranscript}</div>`);
+        } else {
+            result += `<div><b>RingSense transcript</b><br>${formattedTranscript}</div>`;
+        }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        const transcriptRegex = /### RingSense transcript\n([\s\S]*?)(?=\n### |\n$|$)/;
+        if (transcriptRegex.test(result)) {
+            result = result.replace(transcriptRegex, `### RingSense transcript\n${clearedTranscript}\n`);
+        } else {
+            result += `### RingSense transcript\n${clearedTranscript}\n`;
+        }
+    } else {
+        const transcriptRegex = /- RingSense transcript:([\s\S]*?)--- END/;
+        if (transcriptRegex.test(result)) {
+            result = result.replace(transcriptRegex, `- RingSense transcript:\n${clearedTranscript}\n--- END`);
+        } else {
+            result += `- RingSense transcript:\n${clearedTranscript}\n--- END\n`;
+        }
+    }
+    return result;
+}
+
+function upsertRingSenseSummary({ body, summary, logFormat }) {
+    if (!summary) return body;
+
+    let result = body;
+    // remove new line in last line of summary
+    const clearedSummary = summary.replace(/\n+$/, '');
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
+        const summaryRegex = /<div><b>RingSense summary<\/b><br>(.+?)<\/div>/;
+        const formattedSummary = clearedSummary.replace(/(?:\r\n|\r|\n)/g, '<br>');
+        if (summaryRegex.test(result)) {
+            result = result.replace(summaryRegex, `<div><b>RingSense summary</b><br>${formattedSummary}</div>`);
+        } else {
+            result += `<div><b>RingSense summary</b><br>${formattedSummary}</div>`;
+        }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        const summaryRegex = /### RingSense summary\n([\s\S]*?)(?=\n### |\n$|$)/;
+        if (summaryRegex.test(result)) {
+            result = result.replace(summaryRegex, `### RingSense summary\n${summary}\n`);
+        } else {
+            result += `### RingSense summary\n${summary}\n`;
+        }
+    } else {
+        const summaryRegex = /- RingSense summary:([\s\S]*?)--- END/;
+        if (summaryRegex.test(result)) {
+            result = result.replace(summaryRegex, `- RingSense summary:\n${summary}\n--- END`);
+        } else {
+            result += `- RingSense summary:\n${summary}\n--- END\n`;
+        }
+    }
+    return result;
+}
+
+function upsertRingSenseAIScore({ body, score, logFormat }) {
+    if (!score) return body;
+
+    let result = body;
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
+        const scoreRegex = /(?:<li>)?<b>Call score<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
+        if (scoreRegex.test(result)) {
+            result = result.replace(scoreRegex, `<li><b>Call score</b>: ${score}</li>`);
+        } else {
+            result += `<li><b>Call score</b>: ${score}</li>`;
+        }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        const scoreRegex = /\*\*Call score\*\*: [^\n]*\n*/;
+        if (scoreRegex.test(result)) {
+            result = result.replace(scoreRegex, `**Call score**: ${score}\n`);
+        } else {
+            result += `**Call score**: ${score}\n`;
+        }
+    } else {
+        const scoreRegex = /- Call score:\s*([^<\n]+)(?=\n|$)/i;
+        if (scoreRegex.test(result)) {
+            result = result.replace(scoreRegex, `- Call score: ${score}`);
+        } else {
+            result += `- Call score: ${score}\n`;
+        }
+    }
+    return result;
+}
+
+function upsertRingSenseBulletedSummary({ body, summary, logFormat }) {
+    if (!summary) return body;
+
+    let result = body;
+    const clearedSummary = summary.replace(/\n+$/, '');
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
+        const summaryRegex = /<div><b>RingSense bulleted summary<\/b><br>(.+?)<\/div>/;
+        const formattedSummary = clearedSummary.replace(/(?:\r\n|\r|\n)/g, '<br>');
+        if (summaryRegex.test(result)) {
+            result = result.replace(summaryRegex, `<div><b>RingSense bulleted summary</b><br>${formattedSummary}</div>`);
+        } else {
+            result += `<div><b>RingSense bulleted summary</b><br>${formattedSummary}</div>`;
+        }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        const summaryRegex = /### RingSense bulleted summary\n([\s\S]*?)(?=\n### |\n$|$)/;
+        if (summaryRegex.test(result)) {
+            result = result.replace(summaryRegex, `### RingSense bulleted summary\n${summary}\n`);
+        } else {
+            result += `### RingSense bulleted summary\n${summary}\n`;
+        }
+    } else {
+        const summaryRegex = /- RingSense bulleted summary:\s*([^<\n]+)(?=\n|$)/i;
+        if (summaryRegex.test(result)) {
+            result = result.replace(summaryRegex, `- RingSense bulleted summary:\n${summary}\n--- END`);
+        } else {
+            result += `- RingSense bulleted summary:\n${summary}\n--- END\n`;
+        }
+    }
+    return result;
+}
+
+function upsertRingSenseLink({ body, link, logFormat }) {
+    if (!link) return body;
+
+    let result = body;
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
+		const linkRegex = /(?:<li>)?<b>RingSense recording link<\/b>:\s*(?:<a[^>]*>[^<]*<\/a>|[^<]+)(?:<\/li>|(?=<|$))/i;
+        if (linkRegex.test(result)) {
+            result = result.replace(linkRegex, `<li><b>RingSense recording link</b>: <a target="_blank" href="${link}">open</a></li>`);
+        } else {
+            result += `<li><b>RingSense recording link</b>: <a target="_blank" href="${link}">open</a></li>`;
+        }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        const linkRegex = /\*\*RingSense recording link\*\*:\s*([^<\n]+)(?=\n|$)/i;
+        if (linkRegex.test(result)) {
+            result = result.replace(linkRegex, `**RingSense recording link**: ${link}\n`);
+        } else {
+            result += `**RingSense recording link**: ${link}\n`;
+        }
+    } else {
+        const linkRegex = /- RingSense recording link:\s*([^<\n]+)(?=\n|$)/i;
+        if (linkRegex.test(result)) {
+            result = result.replace(linkRegex, `- RingSense recording link: ${link}`);
+        } else {
+            result += `- RingSense recording link: ${link}\n`;
+        }
+    }
+    return result;
+}
+
 module.exports = {
     composeCallLog,
     // Export individual upsert functions for backward compatibility
@@ -631,4 +812,9 @@ module.exports = {
     upsertAiNote,
     upsertTranscript,
     upsertLegs,
+    upsertRingSenseTranscript,
+    upsertRingSenseSummary,
+    upsertRingSenseAIScore,
+    upsertRingSenseBulletedSummary,
+    upsertRingSenseLink,
 };

package/lib/oauth.js

@@ -3,7 +3,6 @@ const ClientOAuth2 = require('client-oauth2');
 const moment = require('moment');
 const { UserModel } = require('../models/userModel');
 const connectorRegistry = require('../connector/registry');
-const dynamoose = require('dynamoose');
 
 // oauthApp strategy is default to 'code' which use credentials to get accessCode, then exchange for accessToken and refreshToken.
 // To change to other strategies, please refer to: https://github.com/mulesoft-labs/js-client-oauth2

package/models/dynamo/connectorSchema.js

@@ -0,0 +1,146 @@
+const dynamoose = require('dynamoose');
+const crypto = require('crypto');
+
+const CONNECTOR_STATUS = {
+  PRIVATE: 'private',
+  UNDER_REVIEW: 'under_review',
+  APPROVED: 'approved',
+  REJECTED: 'rejected',
+};
+
+const connectorSchema = new dynamoose.Schema({
+  accountId: {
+    type: String,
+    hashKey: true,
+  },
+  id: {
+    type: String,
+    rangeKey: true,
+  },
+  // Reference to original connector (for partition records)
+  originalAccountId: {
+    type: String,
+    required: false, // Only set for partition records (under_review, approved)
+  },
+  // Basic Information
+  name: {
+    type: String,
+    required: true,
+  },
+  displayName: String,
+  description: String,
+  iconUrl: String,
+  // Status and Workflow
+  status: {
+    type: String,
+    required: true,
+    enum: Object.values(CONNECTOR_STATUS),
+    default: CONNECTOR_STATUS.PRIVATE,
+    index: {
+      name: 'statusIdIndex',
+      global: true,
+      rangeKey: 'id',
+      project: ['accountId', 'name', 'displayName', 'developer', 'originalAccountId'],
+    },
+  },
+  creatorId: String,
+  // Developer Information
+  developer: {
+    type: Object,
+    schema: {
+      name: String,
+      websiteUrl: String,
+      supportUrl: String,
+    },
+  },
+  // Manifest Management
+  manifest: {
+    type: Object,
+    required: true,
+  },
+  proxyConfig: {
+    type: Object,
+    required: false,
+  },
+  proxyId: {
+    type: String,
+    index: {
+      name: 'proxyIdIndex',
+      global: true,
+      project: ['id', 'accountId', 'creatorId', 'name', 'displayName', 'status', 'developer', 'originalAccountId', 'proxyConfig'],
+    }
+  },
+  // Review and Approval
+  submittedAt: Number,
+  reviewedBy: String,
+  reviewedAt: Number,
+  reviewNotes: String,
+  rejectionReason: String,
+  demoAccounts: String,
+  // Usage and Analytics
+  usageCount: {
+    type: Number,
+    default: 0,
+  },
+  lastUsedAt: Number,
+  allowedAccounts: {
+    type: Array,
+    schema: [String],
+  },
+  encodedSecretKey: String,
+}, {
+  saveUnknown: ['manifest.**', 'proxyConfig.**'],
+  timestamps: true,
+});
+
+const tableOptions = {
+  prefix: process.env.DEVELOPER_DYNAMODB_TABLE_PREFIX,
+};
+
+if (process.env.NODE_ENV === 'production') {
+  tableOptions.create = false;
+  tableOptions.waitForActive = false;
+}
+
+const Connector = dynamoose.model('connectors', connectorSchema, tableOptions);
+
+function getDeveloperCipherKey() {
+  if (!process.env.DEVELOPER_APP_SERVER_SECRET_KEY) {
+    throw new Error('DEVELOPER_APP_SERVER_SECRET_KEY is not defined');
+  }
+  if (process.env.DEVELOPER_APP_SERVER_SECRET_KEY.length < 32) {
+    // pad secret key with spaces if it is less than 32 bytes
+    return process.env.DEVELOPER_APP_SERVER_SECRET_KEY.padEnd(32, ' ');
+  }
+  if (process.env.DEVELOPER_APP_SERVER_SECRET_KEY.length > 32) {
+    // truncate secret key if it is more than 32 bytes
+    return process.env.DEVELOPER_APP_SERVER_SECRET_KEY.slice(0, 32);
+  }
+  return process.env.DEVELOPER_APP_SERVER_SECRET_KEY;
+}
+
+function decode(encryptedData) {
+  const decipher = crypto.createDecipheriv('aes-256-cbc', getDeveloperCipherKey(), Buffer.alloc(16, 0));
+  return decipher.update(encryptedData, 'hex', 'utf8') + decipher.final('utf8');
+}
+
+// ADD static method to get connector by proxyId
+Connector.getProxyConfig = async (proxyId) => {
+  const connectors = await Connector
+    .query('proxyId')
+    .eq(proxyId)
+    .using('proxyIdIndex')
+    .exec();
+  if (connectors.length > 0) {
+    const proxyConfig = connectors[0].proxyConfig;
+    const encodedSecretKey = connectors[0].encodedSecretKey;
+    const secretKey = encodedSecretKey ? decode(encodedSecretKey) : null;
+    if (secretKey) {
+      proxyConfig.secretKey = secretKey;
+    }
+    return proxyConfig;
+  }
+  return null;
+};
+
+exports.Connector = Connector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.0",
+  "version": "1.7.3",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,4 +1,68 @@
 {
+    "1.7.3": {
+        "global": [
+            {
+                "type": "New",
+                "description": "RingSense data logging in server side logging"
+            },
+            {
+                "type": "New",
+                "description": "New phone setting item to group phone related settings"
+            },
+            {
+                "type": "Better",
+                "description": "HUD enabled by default"
+            },
+            {
+                "type": "Fix",
+                "description": "A small issue on contact search feature"
+            },
+            {
+                "type": "Fix",
+                "description": "A small issue on embedded URLs"
+            },
+            {
+                "type": "Fix",
+                "description": "Server-side logging logged calls cannot be edited for the first attempt"
+            }
+        ]
+    },
+    "1.7.1": {
+        "global": [
+            {
+                "type": "Better",
+                "description": "Click-to-SMS now adds recipients so you can easily add multiple recipients"
+            },
+            {
+                "type": "New",
+                "description": "Auto log setting for voicemail"
+            }
+        ]
+    },
+    "1.6.11":{
+        "global": [
+            {
+                "type": "Fix",
+                "description": "A small issue on contact search feature"
+            },
+            {
+                "type": "Fix",
+                "description": "A small issue on embedded URLs"
+            }
+        ]
+    },
+    "1.6.10": {
+        "global": [
+            {
+                "type": "Better",
+                "description": "Click-to-SMS now adds recipients so you can easily add multiple recipients"
+            },
+            {
+                "type": "New",
+                "description": "Auto log setting for voicemail"
+            }
+        ]
+    },
     "1.6.9": {
         "global": [
             {

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