@app-connect/core 1.7.8 → 1.7.11

package/connector/developerPortal.js

@@ -0,0 +1,43 @@
+const axios = require('axios');
+const { logger } = require('../lib/logger');
+
+
+async function getPublicConnectorList() {
+    try {
+        const response = await axios.get('https://appconnect.labs.ringcentral.com/public-api/connectors');
+        return response.data;
+    } catch (error) {
+        logger.error('Error getting public connector list:', error);
+        return null;
+    }
+}
+
+async function getPrivateConnectorList() {
+    try {
+        const response = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/internal?accountId=${process.env.RC_ACCOUNT_ID}`);
+        return response.data;
+    } catch (error) {
+        logger.error('Error getting private connector list:', error);
+        return null;
+    }
+}
+
+async function getConnectorManifest({connectorId, isPrivate = false}) {
+    try {
+        let response = null;
+        if(isPrivate) {
+            response = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${connectorId}/manifest?type=internal&accountId=${process.env.RC_ACCOUNT_ID}`);
+        }
+        else {
+            response = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${connectorId}/manifest`);
+        }
+        return response.data;
+    } catch (error) {
+        logger.error('Error getting connector manifest:', error);
+        return null;
+    }
+}   
+
+exports.getPublicConnectorList = getPublicConnectorList;
+exports.getPrivateConnectorList = getPrivateConnectorList;
+exports.getConnectorManifest = getConnectorManifest;

package/connector/proxy/index.js

@@ -10,6 +10,8 @@ const {
 } = require('./engine');
 const { Connector } = require('../../models/dynamo/connectorSchema');
 const { UserModel } = require('../../models/userModel');
+const logger = require('../../lib/logger');
+const { handleDatabaseError } = require('../../lib/errorHandler');
 
 async function loadPlatformConfig(proxyId) {
   if (!proxyId) {
@@ -19,7 +21,7 @@ async function loadPlatformConfig(proxyId) {
     const proxyConfig = await Connector.getProxyConfig(proxyId);
     return proxyConfig;
   } catch (error) {
-    console.error('Error getting proxy config: ', proxyId);
+    logger.error('Error getting proxy config: ', { proxyId, stack: error.stack });
     return null;
   }
 }
@@ -32,7 +34,7 @@ async function getAuthType({ proxyId, proxyConfig } = {}) {
   return cfg.auth.type || 'apiKey';
 }
 
-async function getOauthInfo({ proxyId, proxyConfig, tokenUrl, hostname } = {}) {
+async function getOauthInfo({ proxyId, proxyConfig, tokenUrl } = {}) {
   const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(proxyId));
   if (!cfg) {
     return {};
@@ -146,7 +148,12 @@ async function unAuthorize({ user }) {
   }
   user.accessToken = '';
   user.refreshToken = '';
-  await user.save();
+  try {
+    await user.save();
+  }
+  catch (error) {
+    return handleDatabaseError(error, 'Error saving user');
+  }
   return {
     successful: true,
     returnMessage: {

package/connector/registry.js

@@ -1,4 +1,5 @@
 // core/src/connector/registry.js
+const logger = require('../lib/logger');
 class ConnectorRegistry {
   constructor() {
       this.connectors = new Map();
@@ -29,7 +30,7 @@ class ConnectorRegistry {
     const platformInterfaceMap = this.platformInterfaces.get(platformName);
     platformInterfaceMap.set(interfaceName, interfaceFunction);
 
-    console.log(`Registered interface function: ${platformName}.${interfaceName}`);
+    logger.info(`Registered interface function: ${platformName}.${interfaceName}`);
   }
 
   /**
@@ -61,7 +62,7 @@ class ConnectorRegistry {
     const platformInterfaceMap = this.platformInterfaces.get(platformName);
     if (platformInterfaceMap && platformInterfaceMap.has(interfaceName)) {
       platformInterfaceMap.delete(interfaceName);
-      console.log(`Unregistered interface function: ${platformName}.${interfaceName}`);
+      logger.info(`Unregistered interface function: ${platformName}.${interfaceName}`);
     }
   }
 
@@ -80,7 +81,7 @@ class ConnectorRegistry {
         this.manifests.set(platform, manifest);
       }
       
-      console.log(`Registered connector: ${platform}`);
+      logger.info(`Registered connector: ${platform}`);
   }
 
   /**
@@ -109,7 +110,7 @@ class ConnectorRegistry {
               composedConnector[interfaceName] = interfaceFunction;
           }
 
-          console.log(`Returning interface-only connector for platform: ${platform}`);
+          logger.info(`Returning interface-only connector for platform: ${platform}`);
           return composedConnector;
       }
 
@@ -203,14 +204,14 @@ class ConnectorRegistry {
       this.connectors.delete(platform);
       this.manifests.delete(platform);
       this.platformInterfaces.delete(platform);
-      console.log(`Unregistered connector: ${platform}`);
+      logger.info(`Unregistered connector: ${platform}`);
   }
 
   setReleaseNotes(releaseNotes) {
     this.releaseNotes = releaseNotes;
   }
 
-  getReleaseNotes(platform) {
+  getReleaseNotes() {
     return this.releaseNotes; 
   }
 
@@ -237,6 +238,7 @@ class ConnectorRegistry {
       try {
         capabilities.authType = await originalConnector.getAuthType();
       } catch (error) {
+        logger.error('Error getting auth type', { stack: error.stack });
         capabilities.authType = 'unknown';
       }
     }

package/handlers/admin.js

@@ -4,6 +4,8 @@ const connectorRegistry = require('../connector/registry');
 const oauth = require('../lib/oauth');
 const { RingCentral } = require('../lib/ringcentral');
 const { Connector } = require('../models/dynamo/connectorSchema');
+const logger = require('../lib/logger');
+const { handleDatabaseError } = require('../lib/errorHandler');
 
 const CALL_AGGREGATION_GROUPS = ["Company", "CompanyNumbers", "Users", "Queues", "IVRs", "IVAs", "SharedLines", "UserGroups", "Sites", "Departments"]
 
@@ -136,7 +138,7 @@ async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo, groupBy
             groupKeys: CALL_AGGREGATION_GROUPS
         };
     } catch (error) {
-        console.error(error);
+        logger.error('Error getting admin report', { error });
         return {
             callLogStats: {}
         };
@@ -206,13 +208,19 @@ async function getUserReport({ rcAccountId, rcExtensionId, timezone, timeFrom, t
         };
         return reportStats;
     } catch (error) {
-        console.error(error);
+        logger.error('Error getting user report', { error });
         return null;
     }
 }
 
 async function getUserMapping({ user, hashedRcAccountId, rcExtensionList }) {
-    const adminConfig = await getAdminSettings({ hashedRcAccountId });
+    let adminConfig = null;
+    try {
+        adminConfig = await getAdminSettings({ hashedRcAccountId });
+    }
+    catch (error) {
+        return handleDatabaseError(error, 'Error getting user mapping');
+    }
     const platformModule = connectorRegistry.getConnector(user.platform);
     if (platformModule.getUserList) {
         const proxyId = user.platformAdditionalInfo?.proxyId;
@@ -318,12 +326,17 @@ async function getUserMapping({ user, hashedRcAccountId, rcExtensionList }) {
                     });
                 }
             }
-            await upsertAdminSettings({
-                hashedRcAccountId,
-                adminSettings: {
-                    userMappings: initialUserMappings
-                }
-            });
+            try {
+                await upsertAdminSettings({
+                    hashedRcAccountId,
+                    adminSettings: {
+                        userMappings: initialUserMappings
+                    }
+                });
+            }
+            catch (error) {
+                return handleDatabaseError(error, 'Error initializing user mapping');
+            }
         }
         // Incremental update
         if (newUserMappings.length > 0) {
@@ -333,20 +346,30 @@ async function getUserMapping({ user, hashedRcAccountId, rcExtensionList }) {
                     ...u,
                     rcExtensionId: [u.rcExtensionId]
                 }));
-                await upsertAdminSettings({
-                    hashedRcAccountId,
-                    adminSettings: {
-                        userMappings: [...adminConfig.userMappings, ...newUserMappings]
-                    }
-                });
+                try {
+                    await upsertAdminSettings({
+                        hashedRcAccountId,
+                        adminSettings: {
+                            userMappings: [...adminConfig.userMappings, ...newUserMappings]
+                        }
+                    });
+                }
+                catch (error) {
+                    return handleDatabaseError(error, 'Error updating user mapping');
+                }
             }
             else {
-                await upsertAdminSettings({
-                    hashedRcAccountId,
-                    adminSettings: {
-                        userMappings: [...newUserMappings]
-                    }
-                });
+                try {
+                    await upsertAdminSettings({
+                        hashedRcAccountId,
+                        adminSettings: {
+                            userMappings: [...newUserMappings]
+                        }
+                    });
+                }
+                catch (error) {
+                    return handleDatabaseError(error, 'Error updating user mapping');
+                }
             }
         }
         return userMappingResult;

package/handlers/auth.js

@@ -5,15 +5,20 @@ const Op = require('sequelize').Op;
 const { RingCentral } = require('../lib/ringcentral');
 const adminCore = require('./admin');
 const { Connector } = require('../models/dynamo/connectorSchema');
+const { handleDatabaseError } = require('../lib/errorHandler');
 
-async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiUrl, username, query, proxyId }) {
+async function onOAuthCallback({ platform, hostname, tokenUrl, query, isFromMCP = false }) {
+    const callbackUri = query.callbackUri;
+    const apiUrl = query.apiUrl;
+    const username = query.username;
+    const proxyId = query.proxyId;
+    const userEmail = query.userEmail;
     const platformModule = connectorRegistry.getConnector(platform);
     let proxyConfig = null;
     if (proxyId) {
         proxyConfig = await Connector.getProxyConfig(proxyId);
     }
-    const oauthInfo = await platformModule.getOauthInfo({ tokenUrl, hostname, rcAccountId: query.rcAccountId, proxyId, proxyConfig });
-
+    const oauthInfo = await platformModule.getOauthInfo({ tokenUrl, hostname, rcAccountId: query.rcAccountId, proxyId, proxyConfig, userEmail, isFromMCP });
     if (oauthInfo.failMessage) {
         return {
             userInfo: null,
@@ -27,27 +32,34 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiU
     // Some platforms require different oauth queries, this won't affect normal OAuth process unless CRM module implements getOverridingOAuthOption() method
     let overridingOAuthOption = null;
     if (platformModule.getOverridingOAuthOption != null) {
-        overridingOAuthOption = platformModule.getOverridingOAuthOption({ code: callbackUri.split('code=')[1] });
+        const code = new URL(callbackUri).searchParams.get('code');
+        overridingOAuthOption = platformModule.getOverridingOAuthOption({ code });
     }
     const oauthApp = oauth.getOAuthApp(oauthInfo);
     const { accessToken, refreshToken, expires } = await oauthApp.code.getToken(callbackUri, overridingOAuthOption);
     const authHeader = `Bearer ${accessToken}`;
-    const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader, tokenUrl, apiUrl, hostname, platform, username, callbackUri, query, proxyId, proxyConfig });
+    const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader, tokenUrl, apiUrl, hostname, platform, username, callbackUri, query, proxyId, proxyConfig, userEmail });
 
     if (successful) {
-        let userInfo = await saveUserInfo({
-            platformUserInfo,
-            platform,
-            tokenUrl,
-            apiUrl,
-            username,
-            hostname: platformUserInfo?.overridingHostname ? platformUserInfo.overridingHostname : hostname,
-            accessToken,
-            refreshToken,
-            tokenExpiry: expires,
-            rcAccountId: query.rcAccountId,
-            proxyId
-        });
+        let userInfo = null;
+        try {
+            userInfo = await saveUserInfo({
+                platformUserInfo,
+                platform,
+                tokenUrl,
+                apiUrl,
+                username,
+                hostname: platformUserInfo?.overridingHostname ? platformUserInfo.overridingHostname : hostname,
+                accessToken,
+                refreshToken,
+                tokenExpiry: expires,
+                rcAccountId: query?.rcAccountId,
+                proxyId
+            });
+        }
+        catch (error) {
+            return handleDatabaseError(error, 'Error saving user info');
+        }
         if (platformModule.postSaveUserInfo) {
             userInfo = await platformModule.postSaveUserInfo({ userInfo, oauthApp });
         }
@@ -69,13 +81,19 @@ async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, additionalIn
     const basicAuth = platformModule.getBasicAuth({ apiKey });
     const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader: `Basic ${basicAuth}`, hostname, platform, additionalInfo, apiKey, proxyId });
     if (successful) {
-        let userInfo = await saveUserInfo({
-            platformUserInfo,
-            platform,
-            hostname,
-            proxyId,
-            accessToken: platformUserInfo.overridingApiKey ?? apiKey
-        });
+        let userInfo = null;
+        try {
+            userInfo = await saveUserInfo({
+                platformUserInfo,
+                platform,
+                hostname,
+                proxyId,
+                accessToken: platformUserInfo.overridingApiKey ?? apiKey
+            });
+        }
+        catch (error) {
+            return handleDatabaseError(error, 'Error saving user info');
+        }
         if (platformModule.postSaveUserInfo) {
             userInfo = await platformModule.postSaveUserInfo({ userInfo });
         }
@@ -101,43 +119,65 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
     const platformAdditionalInfo = platformUserInfo.platformAdditionalInfo || {};
     platformAdditionalInfo.proxyId = proxyId;
     if (existingUser) {
-        await existingUser.update(
-            {
-                platform,
-                hostname,
-                timezoneName,
-                timezoneOffset,
-                accessToken,
-                refreshToken,
-                tokenExpiry,
-                rcAccountId,
-                platformAdditionalInfo: {
-                    ...existingUser.platformAdditionalInfo, // keep existing platformAdditionalInfo
-                    ...platformAdditionalInfo,
-                }
-            }
-        );
-    }
-    else {
-        // TEMP: replace user with old ID
-        if (id.endsWith(`-${platform}`)) {
-            const oldID = id.split('-');
-            const userWithOldID = await UserModel.findByPk(oldID[0]);
-            if (userWithOldID) {
-                await UserModel.create({
-                    id,
+        try {
+            await existingUser.update(
+                {
+                    platform,
                     hostname,
                     timezoneName,
                     timezoneOffset,
-                    platform,
                     accessToken,
                     refreshToken,
                     tokenExpiry,
                     rcAccountId,
-                    platformAdditionalInfo,
-                    userSettings: userWithOldID.userSettings
-                });
-                await userWithOldID.destroy();
+                    platformAdditionalInfo: {
+                        ...existingUser.platformAdditionalInfo, // keep existing platformAdditionalInfo
+                        ...platformAdditionalInfo,
+                    }
+                }
+            );
+        }
+        catch (error) {
+            return handleDatabaseError(error, 'Error saving user info');
+        }
+    }
+    else {
+        try {
+            // TEMP: replace user with old ID
+            if (id.endsWith(`-${platform}`)) {
+                const oldID = id.split('-');
+                const userWithOldID = await UserModel.findByPk(oldID[0]);
+                if (userWithOldID) {
+                    await UserModel.create({
+                        id,
+                        hostname,
+                        timezoneName,
+                        timezoneOffset,
+                        platform,
+                        accessToken,
+                        refreshToken,
+                        tokenExpiry,
+                        rcAccountId,
+                        platformAdditionalInfo,
+                        userSettings: userWithOldID.userSettings
+                    });
+                    await userWithOldID.destroy();
+                }
+                else {
+                    await UserModel.create({
+                        id,
+                        hostname,
+                        timezoneName,
+                        timezoneOffset,
+                        platform,
+                        accessToken,
+                        refreshToken,
+                        tokenExpiry,
+                        rcAccountId,
+                        platformAdditionalInfo,
+                        userSettings: {}
+                    });
+                }
             }
             else {
                 await UserModel.create({
@@ -155,20 +195,8 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
                 });
             }
         }
-        else {
-            await UserModel.create({
-                id,
-                hostname,
-                timezoneName,
-                timezoneOffset,
-                platform,
-                accessToken,
-                refreshToken,
-                tokenExpiry,
-                rcAccountId,
-                platformAdditionalInfo,
-                userSettings: {}
-            });
+        catch (error) {
+            return handleDatabaseError(error, 'Error saving user info');
         }
     }
     return {

package/handlers/calldown.js

@@ -2,8 +2,9 @@ const { UserModel } = require('../models/userModel');
 const { CallDownListModel } = require('../models/callDownListModel');
 const { Op } = require('sequelize');
 const jwt = require('../lib/jwt');
+const { handleDatabaseError } = require('../lib/errorHandler');
 
-async function schedule({ jwtToken, rcAccessToken, body }) {
+async function schedule({ jwtToken, body }) {
     const unAuthData = jwt.decodeJwt(jwtToken);
     if (!unAuthData?.id) throw new Error('Unauthorized');
     const user = await UserModel.findByPk(unAuthData.id);
@@ -48,9 +49,14 @@ async function markCalled({ jwtToken, id, lastCallAt }) {
     const unAuthData = jwt.decodeJwt(jwtToken);
     if (!unAuthData?.id) throw new Error('Unauthorized');
     const when = lastCallAt ? new Date(lastCallAt) : new Date();
-    const [affected] = await CallDownListModel.update({ status: 'called', lastCallAt: when }, { where: { id, userId: unAuthData.id } });
-    if (!affected) throw new Error('Not found');
-    return { successful: true };
+    try {
+        const [affected] = await CallDownListModel.update({ status: 'called', lastCallAt: when }, { where: { id, userId: unAuthData.id } });
+        if (!affected) throw new Error('Not found');
+        return { successful: true };
+    }
+    catch (error) {
+        return handleDatabaseError(error, 'Error marking call as called', { id, userId: unAuthData.id });
+    }
 }
 
 async function update({ jwtToken, id, updateData }) {