@app-connect/core 0.0.2 → 1.5.8

package/lib/callLogComposer.js

@@ -1,18 +1,13 @@
 const moment = require('moment-timezone');
 const { secondsToHoursMinutesSeconds } = require('./util');
 const adapterRegistry = require('../adapter/registry');
+const { LOG_DETAILS_FORMAT_TYPE } = require('./constants');
 
 /**
  * Centralized call log composition module
  * Supports both plain text and HTML formats used across different CRM adapters
  */
 
-// Format types
-const FORMAT_TYPES = {
-    PLAIN_TEXT: 'plainText',
-    HTML: 'html'
-};
-
 /**
  * Compose call log details based on user settings and format type
  * @param {Object} params - Composition parameters
@@ -33,7 +28,7 @@ const FORMAT_TYPES = {
  */
 async function composeCallLog(params) {
     const {
-        logFormat = FORMAT_TYPES.PLAIN_TEXT,
+        logFormat = LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT,
         existingBody = '',
         callLog,
         contactInfo,
@@ -117,67 +112,85 @@ async function composeCallLog(params) {
 
 function upsertCallAgentNote({ body, note, logFormat }) {
     if (!note) return body;
-    if (logFormat === FORMAT_TYPES.HTML) {
+
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // HTML logFormat with proper Agent notes section handling
         const noteRegex = RegExp('<b>Agent notes</b>([\\s\\S]+?)Call details</b>');
         if (noteRegex.test(body)) {
             return body.replace(noteRegex, `<b>Agent notes</b><br>${note}<br><br><b>Call details</b>`);
         }
-        else {
-            return `<b>Agent notes</b><br>${note}<br><br><b>Call details</b><br>` + body;
+        return `<b>Agent notes</b><br>${note}<br><br><b>Call details</b><br>` + body;
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown logFormat with proper Agent notes section handling
+        const noteRegex = /## Agent notes\n([\s\S]*?)\n## Call details/;
+        if (noteRegex.test(body)) {
+            return body.replace(noteRegex, `## Agent notes\n${note}\n\n## Call details`);
+        }
+        if (body.startsWith('## Call details')) {
+            return `## Agent notes\n${note}\n\n` + body;
         }
+        return `## Agent notes\n${note}\n\n## Call details\n` + body;
     } else {
         // Plain text logFormat - FIXED REGEX for multi-line notes with blank lines
         const noteRegex = /- (?:Note|Agent notes): ([\s\S]*?)(?=\n- [A-Z][a-zA-Z\s/]*:|\n$|$)/;
         if (noteRegex.test(body)) {
             return body.replace(noteRegex, `- Note: ${note}`);
-        } else {
-            return `- Note: ${note}\n` + body;
         }
+        return `- Note: ${note}\n` + body;
     }
 }
 
 function upsertCallSessionId({ body, id, logFormat }) {
     if (!id) return body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // More flexible regex that handles both <li> wrapped and unwrapped content
         const idRegex = /(?:<li>)?<b>Session Id<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
         if (idRegex.test(body)) {
             return body.replace(idRegex, `<li><b>Session Id</b>: ${id}</li>`);
-        } else {
-            return body + `<li><b>Session Id</b>: ${id}</li>`;
         }
+        return body + `<li><b>Session Id</b>: ${id}</li>`;
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Session Id**: value
+        const sessionIdRegex = /\*\*Session Id\*\*: [^\n]*\n*/;
+        if (sessionIdRegex.test(body)) {
+            return body.replace(sessionIdRegex, `**Session Id**: ${id}\n`);
+        }
+        return body + `**Session Id**: ${id}\n`;
     } else {
         // Match Session Id field and any trailing newlines, replace with single newline
         const sessionIdRegex = /- Session Id: [^\n]*\n*/;
         if (sessionIdRegex.test(body)) {
             return body.replace(sessionIdRegex, `- Session Id: ${id}\n`);
-        } else {
-            return body + `- Session Id: ${id}\n`;
         }
+        return body + `- Session Id: ${id}\n`;
     }
 }
 
 function upsertCallSubject({ body, subject, logFormat }) {
     if (!subject) return body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // More flexible regex that handles both <li> wrapped and unwrapped content
         const subjectRegex = /(?:<li>)?<b>Summary<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
         if (subjectRegex.test(body)) {
             return body.replace(subjectRegex, `<li><b>Summary</b>: ${subject}</li>`);
-        } else {
-            return body + `<li><b>Summary</b>: ${subject}</li>`;
         }
+        return body + `<li><b>Summary</b>: ${subject}</li>`;
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Summary**: value
+        const subjectRegex = /\*\*Summary\*\*: [^\n]*\n*/;
+        if (subjectRegex.test(body)) {
+            return body.replace(subjectRegex, `**Summary**: ${subject}\n`);
+        }
+        return body + `**Summary**: ${subject}\n`;
     } else {
         // Match Summary field and any trailing newlines, replace with single newline
         const subjectRegex = /- Summary: [^\n]*\n*/;
         if (subjectRegex.test(body)) {
             return body.replace(subjectRegex, `- Summary: ${subject}\n`);
-        } else {
-            return body + `- Summary: ${subject}\n`;
         }
+        return body + `- Summary: ${subject}\n`;
     }
 }
 
@@ -187,7 +200,7 @@ function upsertContactPhoneNumber({ body, phoneNumber, direction, logFormat }) {
     const label = direction === 'Outbound' ? 'Recipient' : 'Caller';
     let result = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // More flexible regex that handles both <li> wrapped and unwrapped content
         const phoneNumberRegex = new RegExp(`(?:<li>)?<b>${label} phone number</b>:\\s*([^<\\n]+)(?:</li>|(?=<|$))`, 'i');
         if (phoneNumberRegex.test(result)) {
@@ -195,6 +208,14 @@ function upsertContactPhoneNumber({ body, phoneNumber, direction, logFormat }) {
         } else {
             result += `<li><b>${label} phone number</b>: ${phoneNumber}</li>`;
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Contact Number**: value
+        const phoneNumberRegex = /\*\*Contact Number\*\*: [^\n]*\n*/;
+        if (phoneNumberRegex.test(result)) {
+            result = result.replace(phoneNumberRegex, `**Contact Number**: ${phoneNumber}\n`);
+        } else {
+            result += `**Contact Number**: ${phoneNumber}\n`;
+        }
     } else {
         // More flexible regex that handles both with and without newlines
         const phoneNumberRegex = /- Contact Number: ([^\n-]+)(?=\n-|\n|$)/;
@@ -225,7 +246,7 @@ function upsertCallDateTime({ body, startTime, timezoneOffset, logFormat }) {
     const formattedDateTime = momentTime.format('YYYY-MM-DD hh:mm:ss A');
     let result = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // More flexible regex that handles both <li> wrapped and unwrapped content
         const dateTimeRegex = /(?:<li>)?<b>Date\/time<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
         if (dateTimeRegex.test(result)) {
@@ -233,6 +254,14 @@ function upsertCallDateTime({ body, startTime, timezoneOffset, logFormat }) {
         } else {
             result += `<li><b>Date/time</b>: ${formattedDateTime}</li>`;
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Date/Time**: value
+        const dateTimeRegex = /\*\*Date\/Time\*\*: [^\n]*\n*/;
+        if (dateTimeRegex.test(result)) {
+            result = result.replace(dateTimeRegex, `**Date/Time**: ${formattedDateTime}\n`);
+        } else {
+            result += `**Date/Time**: ${formattedDateTime}\n`;
+        }
     } else {
         // Handle duplicated Date/Time entries and match complete date/time values
         const dateTimeRegex = /(?:- Date\/Time: [^-]*(?:-[^-]*)*)+/;
@@ -251,7 +280,7 @@ function upsertCallDuration({ body, duration, logFormat }) {
     const formattedDuration = secondsToHoursMinutesSeconds(duration);
     let result = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // More flexible regex that handles both <li> wrapped and unwrapped content
         const durationRegex = /(?:<li>)?<b>Duration<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
         if (durationRegex.test(result)) {
@@ -259,6 +288,14 @@ function upsertCallDuration({ body, duration, logFormat }) {
         } else {
             result += `<li><b>Duration</b>: ${formattedDuration}</li>`;
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Duration**: value
+        const durationRegex = /\*\*Duration\*\*: [^\n]*\n*/;
+        if (durationRegex.test(result)) {
+            result = result.replace(durationRegex, `**Duration**: ${formattedDuration}\n`);
+        } else {
+            result += `**Duration**: ${formattedDuration}\n`;
+        }
     } else {
         // More flexible regex that handles both with and without newlines
         const durationRegex = /- Duration: ([^\n-]+)(?=\n-|\n|$)/;
@@ -276,7 +313,7 @@ function upsertCallResult({ body, result, logFormat }) {
 
     let bodyResult = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         // More flexible regex that handles both <li> wrapped and unwrapped content
         const resultRegex = /(?:<li>)?<b>Result<\/b>:\s*([^<\n]+)(?:<\/li>|(?=<|$))/i;
         if (resultRegex.test(bodyResult)) {
@@ -284,6 +321,14 @@ function upsertCallResult({ body, result, logFormat }) {
         } else {
             bodyResult += `<li><b>Result</b>: ${result}</li>`;
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Result**: value
+        const resultRegex = /\*\*Result\*\*: [^\n]*\n*/;
+        if (resultRegex.test(bodyResult)) {
+            bodyResult = bodyResult.replace(resultRegex, `**Result**: ${result}\n`);
+        } else {
+            bodyResult += `**Result**: ${result}\n`;
+        }
     } else {
         // More flexible regex that handles both with and without newlines
         const resultRegex = /- Result: ([^\n-]+)(?=\n-|\n|$)/;
@@ -297,12 +342,11 @@ function upsertCallResult({ body, result, logFormat }) {
 }
 
 function upsertCallRecording({ body, recordingLink, logFormat }) {
-    // console.log({ m: "upsertCallRecording", recordingLink, hasBody: !!body, logFormat, bodyLength: body?.length });
     if (!recordingLink) return body;
 
     let result = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    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;
         if (recordingLink) {
@@ -326,6 +370,14 @@ function upsertCallRecording({ body, recordingLink, logFormat }) {
                 }
             }
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: **Call recording link**: value
+        const recordingLinkRegex = /\*\*Call recording link\*\*: [^\n]*\n*/;
+        if (recordingLinkRegex.test(result)) {
+            result = result.replace(recordingLinkRegex, `**Call recording link**: ${recordingLink}\n`);
+        } else {
+            result += `**Call recording link**: ${recordingLink}\n`;
+        }
     } else {
         // Match recording link field and any trailing content, replace with single newline
         const recordingLinkRegex = /- Call recording link: [^\n]*\n*/;
@@ -347,7 +399,7 @@ function upsertAiNote({ body, aiNote, logFormat }) {
     const clearedAiNote = aiNote.replace(/\n+$/, '');
     let result = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         const formattedAiNote = clearedAiNote.replace(/(?:\r\n|\r|\n)/g, '<br>');
         const aiNoteRegex = /<div><b>AI Note<\/b><br>(.+?)<\/div>/;
         if (aiNoteRegex.test(result)) {
@@ -355,6 +407,14 @@ function upsertAiNote({ body, aiNote, logFormat }) {
         } else {
             result += `<div><b>AI Note</b><br>${formattedAiNote}</div><br>`;
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: ### AI Note
+        const aiNoteRegex = /### AI Note\n([\s\S]*?)(?=\n### |\n$|$)/;
+        if (aiNoteRegex.test(result)) {
+            result = result.replace(aiNoteRegex, `### AI Note\n${clearedAiNote}\n`);
+        } else {
+            result += `### AI Note\n${clearedAiNote}\n`;
+        }
     } else {
         const aiNoteRegex = /- AI Note:([\s\S]*?)--- END/;
         if (aiNoteRegex.test(result)) {
@@ -371,7 +431,7 @@ function upsertTranscript({ body, transcript, logFormat }) {
 
     let result = body;
 
-    if (logFormat === FORMAT_TYPES.HTML) {
+    if (logFormat === LOG_DETAILS_FORMAT_TYPE.HTML) {
         const formattedTranscript = transcript.replace(/(?:\r\n|\r|\n)/g, '<br>');
         const transcriptRegex = /<div><b>Transcript<\/b><br>(.+?)<\/div>/;
         if (transcriptRegex.test(result)) {
@@ -379,6 +439,14 @@ function upsertTranscript({ body, transcript, logFormat }) {
         } else {
             result += `<div><b>Transcript</b><br>${formattedTranscript}</div><br>`;
         }
+    } else if (logFormat === LOG_DETAILS_FORMAT_TYPE.MARKDOWN) {
+        // Markdown format: ### Transcript
+        const transcriptRegex = /### Transcript\n([\s\S]*?)(?=\n### |\n$|$)/;
+        if (transcriptRegex.test(result)) {
+            result = result.replace(transcriptRegex, `### Transcript\n${transcript}\n`);
+        } else {
+            result += `### Transcript\n${transcript}\n`;
+        }
     } else {
         const transcriptRegex = /- Transcript:([\s\S]*?)--- END/;
         if (transcriptRegex.test(result)) {
@@ -401,43 +469,9 @@ function getLogFormatType(platform) {
     return platformConfig?.logFormat;
 }
 
-/**
- * Create a specialized composition function for specific CRM requirements
- * @param {string} platform - CRM platform name
- * @returns {Function} Customized composition function
- */
-function createComposer(platform) {
-    const logFormat = getLogFormatType(platform);
-
-    return async function (params) {
-        // Add platform-specific formatting
-        if (logFormat === FORMAT_TYPES.HTML && platform === 'pipedrive') {
-            // Pipedrive wraps call details in <ul> tags
-            const composed = await composeCallLog({ ...params, logFormat });
-            if (composed && !composed.includes('<ul>')) {
-                return `<b>Call details</b><ul>${composed}</ul>`;
-            }
-            return composed;
-        }
-
-        if (logFormat === FORMAT_TYPES.HTML && platform === 'bullhorn') {
-            // Bullhorn also wraps call details in <ul> tags
-            const composed = await composeCallLog({ ...params, logFormat });
-            if (composed && !composed.includes('<ul>')) {
-                return `<b>Call details</b><ul>${composed}</ul>`;
-            }
-            return composed;
-        }
-
-        return composeCallLog({ ...params, logFormat });
-    };
-}
-
 module.exports = {
     composeCallLog,
-    createComposer,
     getLogFormatType,
-    FORMAT_TYPES,
     // Export individual upsert functions for backward compatibility
     upsertCallAgentNote,
     upsertCallSessionId,

package/lib/constants.js

@@ -0,0 +1,9 @@
+const LOG_DETAILS_FORMAT_TYPE = {
+    PLAIN_TEXT: 'text/plain',
+    HTML: 'text/html',
+    MARKDOWN: 'text/markdown'
+};
+
+module.exports = {
+    LOG_DETAILS_FORMAT_TYPE
+};

package/lib/oauth.js

@@ -1,8 +1,8 @@
 /* eslint-disable no-param-reassign */
 const ClientOAuth2 = require('client-oauth2');
-const { Lock } = require('../models/dynamo/lockSchema');
 const { UserModel } = require('../models/userModel');
 const adapterRegistry = require('../adapter/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
@@ -31,33 +31,67 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 10)
     }
     // Other CRMs
     if (user && user.accessToken && user.refreshToken && tokenExpiry.getTime() < (dateNow.getTime() + expiryBuffer)) {
+        let newLock;
         // case: use dynamoDB to manage token refresh lock
         if (process.env.USE_TOKEN_REFRESH_LOCK === 'true') {
-            let lock = await Lock.get({ userId: user.id });
-            let newLock;
-            if (!!lock?.ttl && lock.ttl < dateNow.getTime()) {
-                await lock.delete();
-                lock = null;
-            }
-            if (lock) {
-                let processTime = 0;
-                while (!!lock && processTime < tokenLockTimeout) {
-                    await new Promise(resolve => setTimeout(resolve, 2000));    // wait for 2 seconds
-                    processTime += 2;
-                    lock = await Lock.get({ userId: user.id });
-                }
-                // Timeout -> let users try another time
-                if (processTime >= tokenLockTimeout) {
-                    throw new Error('Token lock timeout');
+            const { Lock } = require('../models/dynamo/lockSchema');
+            // Try to atomically create lock only if it doesn't exist
+            try {
+                newLock = await Lock.create(
+                    { 
+                        userId: user.id,
+                        ttl: dateNow.getTime() + 1000 * 30
+                     },
+                    { 
+                        condition: new dynamoose.Condition().where('userId').not().exists()
+                    }
+                );
+                console.log('lock created')
+            } catch (e) {
+                // If creation failed due to condition, a lock exists
+                if (e.name === 'ConditionalCheckFailedException' || e.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
+                    let lock = await Lock.get({ userId: user.id });
+                    if (!!lock?.ttl && lock.ttl < dateNow.getTime()) {
+                        // Try to delete expired lock and create a new one atomically
+                        try {
+                            await lock.delete();
+                            newLock = await Lock.create(
+                                { userId: user.id },
+                                { 
+                                    condition: new dynamoose.Condition().where('userId').not().exists()
+                                }
+                            );
+                        } catch (e2) {
+                            if (e2.name === 'ConditionalCheckFailedException' || e2.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
+                                // Another process created a lock between our delete and create
+                                lock = await Lock.get({ userId: user.id });
+                            } else {
+                                throw e2;
+                            }
+                        }
+                    }
+                    
+                    if (lock && !newLock) {
+                        let processTime = 0;
+                        while (!!lock && processTime < tokenLockTimeout) {
+                            await new Promise(resolve => setTimeout(resolve, 2000));    // wait for 2 seconds
+                            processTime += 2;
+                            lock = await Lock.get({ userId: user.id });
+                        }
+                        // Timeout -> let users try another time
+                        if (processTime >= tokenLockTimeout) {
+                            throw new Error('Token lock timeout');
+                        }
+                        user = await UserModel.findByPk(user.id);
+                        console.log('locked. bypass')
+                        return user;
+                    }
+                } else {
+                    throw e;
                 }
-                user = await UserModel.findByPk(user.id);
-            }
-            else {
-                newLock = await Lock.create({
-                    userId: user.id
-                });
             }
             const token = oauthApp.createToken(user.accessToken, user.refreshToken);
+            console.log('token refreshing...')
             const { accessToken, refreshToken, expires } = await token.refresh();
             user.accessToken = accessToken;
             user.refreshToken = refreshToken;
@@ -66,15 +100,18 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 10)
             if (newLock) {
                 await newLock.delete();
             }
+            console.log('token refreshing finished')
         }
         // case: run withou token refresh lock
         else {
+            console.log('token refreshing...')
             const token = oauthApp.createToken(user.accessToken, user.refreshToken);
             const { accessToken, refreshToken, expires } = await token.refresh();
             user.accessToken = accessToken;
             user.refreshToken = refreshToken;
             user.tokenExpiry = expires;
             await user.save();
+            console.log('token refreshing finished')
         }
 
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "0.0.2",
+  "version": "1.5.8",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {
@@ -35,6 +35,12 @@
     "tz-lookup": "^6.1.25",
     "ua-parser-js": "^1.0.38"
   },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false"
+  },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
     "@octokit/rest": "^19.0.5",

package/releaseNotes.json

@@ -1,4 +1,32 @@
 {
+    "1.5.8": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "- Error on showing a window-size warning message"
+            },
+            {
+                "type": "Fix",
+                "description": "- Disconnected users shown as connected"
+            },
+            {
+                "type": "Better",
+                "description": "- Every 5min, retroatively check recording links at pending state and update them to existing call logs"
+            },
+            {
+                "type": "Better",
+                "description": "- More stable user session"
+            },
+            {
+                "type": "Better",
+                "description": "- User settings sync message suppressed"
+            },
+            {
+                "type": "Better",
+                "description": "- Webpage embed (Click-to-dial and Quick-access-button) urls setting is renamed to 'Enabled domains' under General -> Appearance"
+            }
+        ]
+    },
     "1.5.7": {
         "global": [
             {