@app-connect/core 0.0.1

package/lib/analytics.js

@@ -0,0 +1,53 @@
+const Mixpanel = require('mixpanel');
+const parser = require('ua-parser-js');
+let packageJson = null;
+try {
+    packageJson = require('../package.json');
+}
+catch (e) {
+    packageJson = require('../../package.json');
+}
+const appName = 'App Connect';
+const defaultEventAddedVia = 'server';
+const version = packageJson.version;
+let mixpanel = null;
+
+exports.init = function init() {
+    if (!process.env.MIXPANEL_TOKEN) {
+        return;
+    }
+    mixpanel = Mixpanel.init(process.env.MIXPANEL_TOKEN);
+}
+
+exports.track = function track({ eventName, interfaceName, adapterName, accountId, extensionId, success, requestDuration, userAgent, ip, author, eventAddedVia, extras = null }) {
+    if (!mixpanel || !extensionId) {
+        return;
+    }
+    const inUseEventAddedVia = eventAddedVia || defaultEventAddedVia;
+    mixpanel.people.set_once(extensionId, {
+        version,
+        appName,
+        crmPlatform: adapterName
+    });
+    const ua = parser(userAgent);
+    mixpanel.track(eventName, {
+        distinct_id: extensionId,
+        interfaceName,
+        adapterName,
+        rcAccountId: accountId,
+        extensionId,
+        success,
+        requestDuration,
+        collectedFrom: 'server',
+        version,
+        appName,
+        eventAddedVia: inUseEventAddedVia,
+        $browser: ua.browser.name,
+        $os: ua.os.name,
+        $device: ua.device.type,
+        ip,
+        author,
+        ...extras
+    });
+    console.log(`Event: ${eventName}`);
+}

package/lib/callLogComposer.js

@@ -0,0 +1,452 @@
+const moment = require('moment-timezone');
+const { secondsToHoursMinutesSeconds } = require('./util');
+const adapterRegistry = require('../adapter/registry');
+
+/**
+ * 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
+ * @param {string} params.logFormat - logFormat type: 'plainText' or 'html'
+ * @param {string} params.existingBody - Existing log body (for updates)
+ * @param {Object} params.callLog - Call log information
+ * @param {Object} params.contactInfo - Contact information
+ * @param {Object} params.user - User information
+ * @param {string} params.note - User note
+ * @param {string} params.aiNote - AI generated note
+ * @param {string} params.transcript - Call transcript
+ * @param {string} params.recordingLink - Recording link
+ * @param {string} params.subject - Call subject
+ * @param {Date} params.startTime - Call start time
+ * @param {number} params.duration - Call duration in seconds
+ * @param {string} params.result - Call result
+ * @returns {Promise<string>} Composed log body
+ */
+async function composeCallLog(params) {
+    const {
+        logFormat = FORMAT_TYPES.PLAIN_TEXT,
+        existingBody = '',
+        callLog,
+        contactInfo,
+        user,
+        note,
+        aiNote,
+        transcript,
+        recordingLink,
+        subject,
+        startTime,
+        duration,
+        result,
+        platform
+    } = params;
+
+    let body = existingBody;
+    const userSettings = user.userSettings || {};
+    // Determine timezone handling
+    let resolvedStartTime = startTime || callLog?.startTime;
+    let timezoneOffset = user.timezoneOffset;
+    if (resolvedStartTime) {
+        resolvedStartTime = moment(resolvedStartTime);
+    }
+    // Apply upsert functions based on user settings
+    if (note && (userSettings?.addCallLogNote?.value ?? true)) {
+        body = upsertCallAgentNote({ body, note, logFormat });
+    }
+
+    if (callLog?.sessionId && (userSettings?.addCallSessionId?.value ?? false)) {
+        body = upsertCallSessionId({ body, id: callLog.sessionId, logFormat });
+    }
+
+    if (subject && (userSettings?.addCallLogSubject?.value ?? true)) {
+        body = upsertCallSubject({ body, subject, logFormat });
+    }
+
+    if (contactInfo?.phoneNumber && (userSettings?.addCallLogContactNumber?.value ?? false)) {
+        body = upsertContactPhoneNumber({
+            body,
+            phoneNumber: contactInfo.phoneNumber,
+            direction: callLog?.direction,
+            logFormat
+        });
+    }
+
+    if (resolvedStartTime && (userSettings?.addCallLogDateTime?.value ?? true)) {
+        body = upsertCallDateTime({
+            body,
+            startTime: resolvedStartTime,
+            timezoneOffset,
+            logFormat
+        });
+    }
+
+    if (duration && (userSettings?.addCallLogDuration?.value ?? true)) {
+        body = upsertCallDuration({ body, duration, logFormat });
+    }
+
+    if (result && (userSettings?.addCallLogResult?.value ?? true)) {
+        body = upsertCallResult({ body, result, logFormat });
+    }
+
+    if (recordingLink && (userSettings?.addCallLogRecording?.value ?? true)) {
+        body = upsertCallRecording({ body, recordingLink, logFormat });
+    }
+
+    if (aiNote && (userSettings?.addCallLogAINote?.value ?? true)) {
+        body = upsertAiNote({ body, aiNote, logFormat });
+    }
+
+    if (transcript && (userSettings?.addCallLogTranscript?.value ?? true)) {
+        body = upsertTranscript({ body, transcript, logFormat });
+    }
+
+    return body;
+}
+
+/**
+ * Upsert functions for different log components
+ */
+
+function upsertCallAgentNote({ body, note, logFormat }) {
+    if (!note) return body;
+    if (logFormat === FORMAT_TYPES.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;
+        }
+    } 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;
+        }
+    }
+}
+
+function upsertCallSessionId({ body, id, logFormat }) {
+    if (!id) return body;
+
+    if (logFormat === FORMAT_TYPES.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>`;
+        }
+    } 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`;
+        }
+    }
+}
+
+function upsertCallSubject({ body, subject, logFormat }) {
+    if (!subject) return body;
+
+    if (logFormat === FORMAT_TYPES.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>`;
+        }
+    } 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`;
+        }
+    }
+}
+
+function upsertContactPhoneNumber({ body, phoneNumber, direction, logFormat }) {
+    if (!phoneNumber) return body;
+
+    const label = direction === 'Outbound' ? 'Recipient' : 'Caller';
+    let result = body;
+
+    if (logFormat === FORMAT_TYPES.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)) {
+            result = result.replace(phoneNumberRegex, `<li><b>${label} phone number</b>: ${phoneNumber}</li>`);
+        } else {
+            result += `<li><b>${label} phone number</b>: ${phoneNumber}</li>`;
+        }
+    } else {
+        // More flexible regex that handles both with and without newlines
+        const phoneNumberRegex = /- Contact Number: ([^\n-]+)(?=\n-|\n|$)/;
+        if (phoneNumberRegex.test(result)) {
+            result = result.replace(phoneNumberRegex, `- Contact Number: ${phoneNumber}\n`);
+        } else {
+            result += `- Contact Number: ${phoneNumber}\n`;
+        }
+    }
+    return result;
+}
+
+function upsertCallDateTime({ body, startTime, timezoneOffset, logFormat }) {
+    if (!startTime) return body;
+
+    // Simple approach: convert to moment and apply timezone offset
+    let momentTime = moment(startTime);
+    if (timezoneOffset) {
+        // Handle both string offsets ('+05:30') and numeric offsets (330 minutes or 5.5 hours)
+        if (typeof timezoneOffset === 'string' && timezoneOffset.includes(':')) {
+            // String logFormat like '+05:30' or '-05:00'
+            momentTime = momentTime.utcOffset(timezoneOffset);
+        } else {
+            // Numeric logFormat (minutes or hours)
+            momentTime = momentTime.utcOffset(Number(timezoneOffset));
+        }
+    }
+    const formattedDateTime = momentTime.format('YYYY-MM-DD hh:mm:ss A');
+    let result = body;
+
+    if (logFormat === FORMAT_TYPES.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)) {
+            result = result.replace(dateTimeRegex, `<li><b>Date/time</b>: ${formattedDateTime}</li>`);
+        } else {
+            result += `<li><b>Date/time</b>: ${formattedDateTime}</li>`;
+        }
+    } else {
+        // Handle duplicated Date/Time entries and match complete date/time values
+        const dateTimeRegex = /(?:- Date\/Time: [^-]*(?:-[^-]*)*)+/;
+        if (dateTimeRegex.test(result)) {
+            result = result.replace(dateTimeRegex, `- Date/Time: ${formattedDateTime}\n`);
+        } else {
+            result += `- Date/Time: ${formattedDateTime}\n`;
+        }
+    }
+    return result;
+}
+
+function upsertCallDuration({ body, duration, logFormat }) {
+    if (!duration) return body;
+
+    const formattedDuration = secondsToHoursMinutesSeconds(duration);
+    let result = body;
+
+    if (logFormat === FORMAT_TYPES.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)) {
+            result = result.replace(durationRegex, `<li><b>Duration</b>: ${formattedDuration}</li>`);
+        } else {
+            result += `<li><b>Duration</b>: ${formattedDuration}</li>`;
+        }
+    } else {
+        // 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`);
+        } else {
+            result += `- Duration: ${formattedDuration}\n`;
+        }
+    }
+    return result;
+}
+
+function upsertCallResult({ body, result, logFormat }) {
+    if (!result) return body;
+
+    let bodyResult = body;
+
+    if (logFormat === FORMAT_TYPES.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)) {
+            bodyResult = bodyResult.replace(resultRegex, `<li><b>Result</b>: ${result}</li>`);
+        } else {
+            bodyResult += `<li><b>Result</b>: ${result}</li>`;
+        }
+    } else {
+        // 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`);
+        } else {
+            bodyResult += `- Result: ${result}\n`;
+        }
+    }
+    return bodyResult;
+}
+
+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) {
+        // 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) {
+            if (recordingLinkRegex.test(result)) {
+                if (recordingLink.startsWith('http')) {
+                    result = result.replace(recordingLinkRegex, `<li><b>Call recording link</b>: <a target="_blank" href="${recordingLink}">open</a></li>`);
+                } else {
+                    result = result.replace(recordingLinkRegex, `<li><b>Call recording link</b>: (pending...)</li>`);
+                }
+            } else {
+                let text = '';
+                if (recordingLink.startsWith('http')) {
+                    text = `<li><b>Call recording link</b>: <a target="_blank" href="${recordingLink}">open</a></li>`;
+                } else {
+                    text = '<li><b>Call recording link</b>: (pending...)</li>';
+                }
+                if (result.indexOf('</ul>') === -1) {
+                    result += text;
+                } else {
+                    result = result.replace('</ul>', `${text}</ul>`);
+                }
+            }
+        }
+    } else {
+        // Match recording link field and any trailing content, replace with single newline
+        const recordingLinkRegex = /- Call recording link: [^\n]*\n*/;
+        if (recordingLinkRegex.test(result)) {
+            result = result.replace(recordingLinkRegex, `- Call recording link: ${recordingLink}\n`);
+        } else {
+            if (result && !result.endsWith('\n')) {
+                result += '\n';
+            }
+            result += `- Call recording link: ${recordingLink}\n`;
+        }
+    }
+    return result;
+}
+
+function upsertAiNote({ body, aiNote, logFormat }) {
+    if (!aiNote) return body;
+
+    const clearedAiNote = aiNote.replace(/\n+$/, '');
+    let result = body;
+
+    if (logFormat === FORMAT_TYPES.HTML) {
+        const formattedAiNote = clearedAiNote.replace(/(?:\r\n|\r|\n)/g, '<br>');
+        const aiNoteRegex = /<div><b>AI Note<\/b><br>(.+?)<\/div>/;
+        if (aiNoteRegex.test(result)) {
+            result = result.replace(aiNoteRegex, `<div><b>AI Note</b><br>${formattedAiNote}</div>`);
+        } else {
+            result += `<div><b>AI Note</b><br>${formattedAiNote}</div><br>`;
+        }
+    } else {
+        const aiNoteRegex = /- AI Note:([\s\S]*?)--- END/;
+        if (aiNoteRegex.test(result)) {
+            result = result.replace(aiNoteRegex, `- AI Note:\n${clearedAiNote}\n--- END`);
+        } else {
+            result += `- AI Note:\n${clearedAiNote}\n--- END\n`;
+        }
+    }
+    return result;
+}
+
+function upsertTranscript({ body, transcript, logFormat }) {
+    if (!transcript) return body;
+
+    let result = body;
+
+    if (logFormat === FORMAT_TYPES.HTML) {
+        const formattedTranscript = transcript.replace(/(?:\r\n|\r|\n)/g, '<br>');
+        const transcriptRegex = /<div><b>Transcript<\/b><br>(.+?)<\/div>/;
+        if (transcriptRegex.test(result)) {
+            result = result.replace(transcriptRegex, `<div><b>Transcript</b><br>${formattedTranscript}</div>`);
+        } else {
+            result += `<div><b>Transcript</b><br>${formattedTranscript}</div><br>`;
+        }
+    } else {
+        const transcriptRegex = /- Transcript:([\s\S]*?)--- END/;
+        if (transcriptRegex.test(result)) {
+            result = result.replace(transcriptRegex, `- Transcript:\n${transcript}\n--- END`);
+        } else {
+            result += `- Transcript:\n${transcript}\n--- END\n`;
+        }
+    }
+    return result;
+}
+
+/**
+ * Helper function to determine format type for a CRM platform
+ * @param {string} platform - CRM platform name
+ * @returns {string} Format type
+ */
+function getLogFormatType(platform) {
+    const manifest = adapterRegistry.getManifest(platform, true);
+    const platformConfig = manifest.platforms?.[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,
+    upsertCallSubject,
+    upsertContactPhoneNumber,
+    upsertCallDateTime,
+    upsertCallDuration,
+    upsertCallResult,
+    upsertCallRecording,
+    upsertAiNote,
+    upsertTranscript
+}; 

package/lib/encode.js

@@ -0,0 +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;

package/lib/generalErrorMessage.js

@@ -0,0 +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;
+exports.authorizationErrorMessage = authorizationErrorMessage;

package/lib/jwt.js

@@ -0,0 +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;

package/lib/oauth.js

@@ -0,0 +1,85 @@
+/* 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');
+
+// 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
+function getOAuthApp({ clientId, clientSecret, accessTokenUri, authorizationUri, redirectUri, scopes }) {
+    return new ClientOAuth2({
+        clientId: clientId,
+        clientSecret: clientSecret,
+        accessTokenUri: accessTokenUri,
+        authorizationUri: authorizationUri,
+        redirectUri: redirectUri,
+        scopes: scopes
+    });
+}
+
+
+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
+    // Special case: Bullhorn
+    if (user.platform) {
+        const platformModule = adapterRegistry.getAdapter(user.platform);
+        if (platformModule.checkAndRefreshAccessToken) {
+            return platformModule.checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout);
+        }
+    }
+    // Other CRMs
+    if (user && user.accessToken && user.refreshToken && tokenExpiry.getTime() < (dateNow.getTime() + expiryBuffer)) {
+        // 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');
+                }
+                user = await UserModel.findByPk(user.id);
+            }
+            else {
+                newLock = await Lock.create({
+                    userId: user.id
+                });
+            }
+            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();
+            if (newLock) {
+                await newLock.delete();
+            }
+        }
+        // case: run withou token refresh lock
+        else {
+            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();
+        }
+
+    }
+    return user;
+}
+
+exports.checkAndRefreshAccessToken = checkAndRefreshAccessToken;
+exports.getOAuthApp = getOAuthApp;