@app-connect/core 0.0.3 → 1.6.4

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/encode.js

@@ -1,30 +1,30 @@
-const crypto = require('crypto');
-
-function getCipherKey() {
-  if (!process.env.APP_SERVER_SECRET_KEY) {
-    throw new Error('APP_SERVER_SECRET_KEY is not defined');
-  }
-  if (process.env.APP_SERVER_SECRET_KEY.length < 32) {
-    // pad secret key with spaces if it is less than 32 bytes
-    return process.env.APP_SERVER_SECRET_KEY.padEnd(32, ' ');
-  }
-  if (process.env.APP_SERVER_SECRET_KEY.length > 32) {
-    // truncate secret key if it is more than 32 bytes
-    return process.env.APP_SERVER_SECRET_KEY.slice(0, 32);
-  }
-  return process.env.APP_SERVER_SECRET_KEY;
-}
-
-function encode(data) {
-  const cipher = crypto.createCipheriv('aes-256-cbc', getCipherKey(), Buffer.alloc(16, 0));
-  return cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
-}
-
-function decoded(encryptedData) {
-  const decipher = crypto.createDecipheriv('aes-256-cbc', getCipherKey(), Buffer.alloc(16, 0));
-  return decipher.update(encryptedData, 'hex', 'utf8') + decipher.final('utf8');
-}
-
-
-exports.encode = encode;
-exports.decoded = decoded;
+const crypto = require('crypto');
+
+function getCipherKey() {
+  if (!process.env.APP_SERVER_SECRET_KEY) {
+    throw new Error('APP_SERVER_SECRET_KEY is not defined');
+  }
+  if (process.env.APP_SERVER_SECRET_KEY.length < 32) {
+    // pad secret key with spaces if it is less than 32 bytes
+    return process.env.APP_SERVER_SECRET_KEY.padEnd(32, ' ');
+  }
+  if (process.env.APP_SERVER_SECRET_KEY.length > 32) {
+    // truncate secret key if it is more than 32 bytes
+    return process.env.APP_SERVER_SECRET_KEY.slice(0, 32);
+  }
+  return process.env.APP_SERVER_SECRET_KEY;
+}
+
+function encode(data) {
+  const cipher = crypto.createCipheriv('aes-256-cbc', getCipherKey(), Buffer.alloc(16, 0));
+  return cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
+}
+
+function decoded(encryptedData) {
+  const decipher = crypto.createDecipheriv('aes-256-cbc', getCipherKey(), Buffer.alloc(16, 0));
+  return decipher.update(encryptedData, 'hex', 'utf8') + decipher.final('utf8');
+}
+
+
+exports.encode = encode;
+exports.decoded = decoded;

package/lib/generalErrorMessage.js

@@ -1,42 +1,42 @@
-function rateLimitErrorMessage({ platform }) {
-    return {
-        message: `Rate limit exceeded`,
-        messageType: 'warning',
-        details: [
-            {
-                title: 'Details',
-                items: [
-                    {
-                        id: '1',
-                        type: 'text',
-                        text: `You have exceeded the maximum number of requests allowed by ${platform}. Please try again in the next minute. If the problem persists please contact support.`
-                    }
-                ]
-            }
-        ],
-        ttl: 5000
-    }
-}
-
-function authorizationErrorMessage({ platform }) {
-    return {
-        message: `Authorization error`,
-        messageType: 'warning',
-        details: [
-            {
-                title: 'Details',
-                items: [
-                    {
-                        id: '1',
-                        type: 'text',
-                        text: `It seems like there's something wrong with your authorization of ${platform}. Please Logout and then Connect your ${platform} account within this extension.`
-                    }
-                ]
-            }
-        ],
-        ttl: 5000
-    }
-}
-
-exports.rateLimitErrorMessage = rateLimitErrorMessage;
+function rateLimitErrorMessage({ platform }) {
+    return {
+        message: `Rate limit exceeded`,
+        messageType: 'warning',
+        details: [
+            {
+                title: 'Details',
+                items: [
+                    {
+                        id: '1',
+                        type: 'text',
+                        text: `You have exceeded the maximum number of requests allowed by ${platform}. Please try again in the next minute. If the problem persists please contact support.`
+                    }
+                ]
+            }
+        ],
+        ttl: 5000
+    }
+}
+
+function authorizationErrorMessage({ platform }) {
+    return {
+        message: `Authorization error`,
+        messageType: 'warning',
+        details: [
+            {
+                title: 'Details',
+                items: [
+                    {
+                        id: '1',
+                        type: 'text',
+                        text: `It seems like there's something wrong with your authorization of ${platform}. Please Logout and then Connect your ${platform} account within this extension.`
+                    }
+                ]
+            }
+        ],
+        ttl: 5000
+    }
+}
+
+exports.rateLimitErrorMessage = rateLimitErrorMessage;
 exports.authorizationErrorMessage = authorizationErrorMessage;

package/lib/jwt.js

@@ -1,16 +1,16 @@
-const { sign, verify } = require('jsonwebtoken');
-
-function generateJwt(data) {
-  return sign(data, process.env.APP_SERVER_SECRET_KEY, { expiresIn: '120y' })
-}
-
-function decodeJwt(token) {
-  try {
-    return verify(token, process.env.APP_SERVER_SECRET_KEY);
-  } catch (e) {
-    return null;
-  }
-}
-
-exports.generateJwt = generateJwt;
-exports.decodeJwt = decodeJwt;
+const { sign, verify } = require('jsonwebtoken');
+
+function generateJwt(data) {
+  return sign(data, process.env.APP_SERVER_SECRET_KEY, { expiresIn: '120y' })
+}
+
+function decodeJwt(token) {
+  try {
+    return verify(token, process.env.APP_SERVER_SECRET_KEY);
+  } catch (e) {
+    return null;
+  }
+}
+
+exports.generateJwt = generateJwt;
+exports.decodeJwt = decodeJwt;

package/lib/oauth.js

@@ -1,8 +1,9 @@
 /* eslint-disable no-param-reassign */
 const ClientOAuth2 = require('client-oauth2');
-const { Lock } = require('../models/dynamo/lockSchema');
+const moment = require('moment');
 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
@@ -18,10 +19,10 @@ function getOAuthApp({ clientId, clientSecret, accessTokenUri, authorizationUri,
 }
 
 
-async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 10) {
-    const dateNow = new Date();
-    const tokenExpiry = new Date(user.tokenExpiry);
-    const expiryBuffer = 1000 * 60 * 2; // 2 minutes => 120000ms
+async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20) {
+    const now = moment();
+    const tokenExpiry = moment(user.tokenExpiry);
+    const expiryBuffer = 2; // 2 minutes
     // Special case: Bullhorn
     if (user.platform) {
         const platformModule = adapterRegistry.getAdapter(user.platform);
@@ -29,52 +30,101 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 10)
             return platformModule.checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout);
         }
     }
-    // Other CRMs
-    if (user && user.accessToken && user.refreshToken && tokenExpiry.getTime() < (dateNow.getTime() + expiryBuffer)) {
+    // Other CRMs - check if token will expire within the buffer time
+    if (user && user.accessToken && user.refreshToken && tokenExpiry.isBefore(now.clone().add(expiryBuffer, 'minutes'))) {
         // case: use dynamoDB to manage token refresh lock
-        if (process.env.USE_TOKEN_REFRESH_LOCK === 'true') {
-            let lock = await Lock.get({ userId: user.id });
+        if (adapterRegistry.getManifest('default')?.platforms?.[user.platform]?.auth?.useTokenRefreshLock) {
             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: now.unix() + 30
+                    },
+                    {
+                        overwrite: false
+                    }
+                );
+                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 && moment(lock.ttl).unix() < now.unix()) {
+                        // Try to delete expired lock and create a new one atomically
+                        try {
+                            console.log('lock expired.')
+                            await lock.delete();
+                            newLock = await Lock.create(
+                                {
+                                    userId: user.id,
+                                    ttl: now.unix() + 30
+                                },
+                                {
+                                    overwrite: false
+                                }
+                            );
+                        } 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;
+                        let delay = 500; // Start with 500ms
+                        const maxDelay = 8000; // Cap at 8 seconds
+                        while (!!lock && processTime < tokenLockTimeout) {
+                            await new Promise(resolve => setTimeout(resolve, delay));
+                            processTime += delay / 1000; // Convert to seconds for comparison
+                            delay = Math.min(delay * 2, maxDelay); // Exponential backoff with cap
+                            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 startRefreshTime = moment();
             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;
             user.tokenExpiry = expires;
             await user.save();
             if (newLock) {
+                const deletionStartTime = moment();
                 await newLock.delete();
+                const deletionEndTime = moment();
+                console.log(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`)
             }
+            const endRefreshTime = moment();
+            console.log(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`)
         }
         // 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/lib/util.js

@@ -1,40 +1,43 @@
-
-const tzlookup = require('tz-lookup');
-const { State } = require('country-state-city');
-const crypto = require('crypto');
-
-function getTimeZone(countryCode, stateCode) {
-    const state = State.getStateByCodeAndCountry(stateCode, countryCode);
-    if (!state) {
-        return 'Unknown timezone';
-    }
-    const timezone = tzlookup(state.latitude, state.longitude);
-    return timezone;
-}
-
-
-function getHashValue(string, secretKey) {
-    return crypto.createHash('sha256').update(
-        `${string}:${secretKey}`
-    ).digest('hex');
-}
-
-function secondsToHoursMinutesSeconds(seconds) {
-    // If not a number, return the input directly
-    if (isNaN(seconds)) {
-        return seconds;
-    }
-    const hours = Math.floor(seconds / 3600);
-    const hoursString = hours > 0 ? `${hours} ${hours > 1 ? 'hours' : 'hour'}` : '';
-    const minutes = Math.floor((seconds % 3600) / 60);
-    const minutesString = minutes > 0 ? `${minutes} ${minutes > 1 ? 'minutes' : 'minute'}` : '';
-    const remainingSeconds = seconds % 60;
-    const secondsString = remainingSeconds > 0 ? `${remainingSeconds} ${remainingSeconds > 1 ? 'seconds' : 'second'}` : '';
-    const resultString = [hoursString, minutesString, secondsString].filter(Boolean).join(', ');
-    return resultString;
-}
-
-exports.getTimeZone = getTimeZone;
-exports.getHashValue = getHashValue;
-exports.secondsToHoursMinutesSeconds = secondsToHoursMinutesSeconds;
-
+
+const tzlookup = require('tz-lookup');
+const { State } = require('country-state-city');
+const crypto = require('crypto');
+
+function getTimeZone(countryCode, stateCode) {
+    const state = State.getStateByCodeAndCountry(stateCode, countryCode);
+    if (!state) {
+        return 'Unknown timezone';
+    }
+    const timezone = tzlookup(state.latitude, state.longitude);
+    return timezone;
+}
+
+
+function getHashValue(string, secretKey) {
+    return crypto.createHash('sha256').update(
+        `${string}:${secretKey}`
+    ).digest('hex');
+}
+
+function secondsToHoursMinutesSeconds(seconds) {
+    // If not a number, return the input directly
+    if (isNaN(seconds)) {
+        return seconds;
+    }
+    const hours = Math.floor(seconds / 3600);
+    const hoursString = hours > 0 ? `${hours} ${hours > 1 ? 'hours' : 'hour'}` : '';
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const minutesString = minutes > 0 ? `${minutes} ${minutes > 1 ? 'minutes' : 'minute'}` : '';
+    const remainingSeconds = seconds % 60;
+    const secondsString = remainingSeconds > 0 ? `${remainingSeconds} ${remainingSeconds > 1 ? 'seconds' : 'second'}` : '';
+    if (!hoursString && !minutesString && !secondsString) {
+        return '0 seconds';
+    }
+    const resultString = [hoursString, minutesString, secondsString].filter(Boolean).join(', ');
+    return resultString;
+}
+
+exports.getTimeZone = getTimeZone;
+exports.getHashValue = getHashValue;
+exports.secondsToHoursMinutesSeconds = secondsToHoursMinutesSeconds;
+

package/models/adminConfigModel.js

@@ -1,17 +1,17 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for User data
-exports.AdminConfigModel = sequelize.define('adminConfigs', {
-  // hashed rc account ID
-  id: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  userSettings: {
-    type: Sequelize.JSON
-  },
-  customAdapter: {
-    type: Sequelize.JSON
-  }
-});
+const Sequelize = require('sequelize');
+const { sequelize } = require('./sequelize');
+
+// Model for User data
+exports.AdminConfigModel = sequelize.define('adminConfigs', {
+  // hashed rc account ID
+  id: {
+    type: Sequelize.STRING,
+    primaryKey: true,
+  },
+  userSettings: {
+    type: Sequelize.JSON
+  },
+  customAdapter: {
+    type: Sequelize.JSON
+  }
+});

package/models/cacheModel.js

@@ -1,23 +1,23 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for cache data
-exports.CacheModel = sequelize.define('cache', {
-    // id = {userId}-{cacheKey}
-    id: {
-        type: Sequelize.STRING,
-        primaryKey: true,
-    },
-    status: {
-        type: Sequelize.STRING,
-    },
-    userId: {
-        type: Sequelize.STRING,
-    },
-    cacheKey: {
-        type: Sequelize.STRING,
-    },
-    expiry: {
-        type: Sequelize.DATE
-    }
-});
+const Sequelize = require('sequelize');
+const { sequelize } = require('./sequelize');
+
+// Model for cache data
+exports.CacheModel = sequelize.define('cache', {
+    // id = {userId}-{cacheKey}
+    id: {
+        type: Sequelize.STRING,
+        primaryKey: true,
+    },
+    status: {
+        type: Sequelize.STRING,
+    },
+    userId: {
+        type: Sequelize.STRING,
+    },
+    cacheKey: {
+        type: Sequelize.STRING,
+    },
+    expiry: {
+        type: Sequelize.DATE
+    }
+});

package/models/callLogModel.js

@@ -1,27 +1,27 @@
-const Sequelize = require('sequelize');
-const { sequelize } = require('./sequelize');
-
-// Model for User data
-exports.CallLogModel = sequelize.define('callLogs', {
-  // callId
-  id: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  sessionId: {
-    type: Sequelize.STRING,
-    primaryKey: true,
-  },
-  platform: {
-    type: Sequelize.STRING,
-  },
-  thirdPartyLogId: {
-    type: Sequelize.STRING,
-  },
-  userId: {
-    type: Sequelize.STRING,
-  },
-  contactId: {
-    type: Sequelize.STRING,
-  }
-});
+const Sequelize = require('sequelize');
+const { sequelize } = require('./sequelize');
+
+// Model for User data
+exports.CallLogModel = sequelize.define('callLogs', {
+  // callId
+  id: {
+    type: Sequelize.STRING,
+    primaryKey: true,
+  },
+  sessionId: {
+    type: Sequelize.STRING,
+    primaryKey: true,
+  },
+  platform: {
+    type: Sequelize.STRING,
+  },
+  thirdPartyLogId: {
+    type: Sequelize.STRING,
+  },
+  userId: {
+    type: Sequelize.STRING,
+  },
+  contactId: {
+    type: Sequelize.STRING,
+  }
+});

package/models/dynamo/lockSchema.js

@@ -1,25 +1,25 @@
-const dynamoose = require('dynamoose');
-
-const lockSchema = new dynamoose.Schema({
-    userId: {
-        type: String,
-        hashKey: true
-    },
-    ttl: {
-      type: Number
-    }
-});
-
-const tableOptions = {
-    prefix: process.env.DYNAMODB_TABLE_PREFIX,
-    expires: 60 // 60 seconds
-};
-
-if (process.env.NODE_ENV === 'production') {
-    tableOptions.create = false;
-    tableOptions.waitForActive = false;
-}
-
-const Lock = dynamoose.model('-token-refresh-lock', lockSchema, tableOptions);
-
+const dynamoose = require('dynamoose');
+
+const lockSchema = new dynamoose.Schema({
+    userId: {
+        type: String,
+        hashKey: true
+    },
+    ttl: {
+      type: Number
+    }
+});
+
+const tableOptions = {
+    prefix: process.env.DYNAMODB_TABLE_PREFIX,
+    expires: 60 // 60 seconds
+};
+
+if (process.env.NODE_ENV === 'production') {
+    tableOptions.create = false;
+    tableOptions.waitForActive = false;
+}
+
+const Lock = dynamoose.model('-token-refresh-lock', lockSchema, tableOptions);
+
 exports.Lock = Lock;

package/models/dynamo/noteCacheSchema.js

@@ -0,0 +1,30 @@
+const dynamoose = require('dynamoose');
+
+const noteCacheSchema = new dynamoose.Schema({
+    sessionId: {
+        type: String,
+        hashKey: true,
+    },
+    note: {
+        type: String,
+        required: true,
+    },
+    ttl: {
+        type: Number,
+        required: true,
+    },
+});
+
+const tableOptions = {
+    prefix: process.env.DYNAMODB_TABLE_PREFIX,
+    expires: 60 // 60 seconds
+};
+
+if (process.env.NODE_ENV === 'production') {
+    tableOptions.create = false;
+    tableOptions.waitForActive = false;
+}
+
+const NoteCache = dynamoose.model('-note-cache', noteCacheSchema, tableOptions);
+
+exports.NoteCache = NoteCache;