@app-connect/core 1.7.10 → 1.7.12

package/lib/errorHandler.js

@@ -0,0 +1,206 @@
+const logger = require('./logger');
+const errorMessage = require('./generalErrorMessage');
+
+/**
+ * Centralized error handler for API operations
+ * Handles common error patterns (rate limits, auth errors, etc.)
+ * 
+ * @param {Error} error - The error object
+ * @param {string} platform - Platform name (clio, bullhorn, etc.)
+ * @param {string} operation - Operation name (createCallLog, findContact, etc.)
+ * @param {Object} additionalContext - Additional logging context
+ * @returns {Object} Standardized error response
+ */
+function handleApiError(error, platform, operation, additionalContext = {}) {
+  const statusCode = error.response?.status ?? 'unknown';
+  
+  // Log the error with full context
+  logger.error(`${operation} failed for platform ${platform}`, {
+    platform,
+    operation,
+    statusCode,
+    errorMessage: error.message,
+    errorStack: error.stack,
+    errorResponse: error.response?.data,
+    ...additionalContext,
+  });
+
+  // Rate limit error (429)
+  if (statusCode === 429) {
+    return {
+      successful: false,
+      returnMessage: errorMessage.rateLimitErrorMessage({ platform }),
+      extraDataTracking: {
+        statusCode,
+      },
+    };
+  }
+
+  // Authorization/Authentication errors (400-409)
+  if (statusCode >= 400 && statusCode < 410) {
+    return {
+      successful: false,
+      returnMessage: errorMessage.authorizationErrorMessage({ platform }),
+      extraDataTracking: {
+        statusCode,
+      },
+    };
+  }
+
+  // Get operation-specific error message
+  const defaultErrorMessage = getOperationErrorMessage(operation, platform);
+
+  return {
+    successful: false,
+    returnMessage: defaultErrorMessage,
+    extraDataTracking: {
+      statusCode,
+    },
+  };
+}
+
+/**
+ * Get operation-specific error message
+ * @param {string} operation - Operation name
+ * @param {string} platform - Platform name
+ * @returns {Object} Error message object
+ */
+function getOperationErrorMessage(operation, platform) {
+  const operationMessages = {
+    createCallLog: {
+      message: 'Error creating call log',
+      details: ['Please check if your account has permission to CREATE logs.'],
+    },
+    updateCallLog: {
+      message: 'Error updating call log',
+      details: [`Please check if the log entity still exists on ${platform} and your account has permission to EDIT logs.`],
+    },
+    getCallLog: {
+      message: 'Error getting call log',
+      details: ['Please check if your account has permission to READ logs.'],
+    },
+    createMessageLog: {
+      message: 'Error creating message log',
+      details: ['Please check if your account has permission to CREATE logs.'],
+    },
+    updateMessageLog: {
+      message: 'Error updating message log',
+      details: [`Please check if the log entity still exists on ${platform} and your account has permission to EDIT logs.`],
+    },
+    findContact: {
+      message: 'Error finding contact',
+      details: ['Please check if your account has permission to GET contacts.'],
+    },
+    createContact: {
+      message: 'Error creating contact',
+      details: ['Please check if your account has permission to CREATE contacts.'],
+    },
+    findContactWithName: {
+      message: 'Error searching contacts',
+      details: ['Please check if your account has permission to GET contacts.'],
+    },
+  };
+
+  const operationInfo = operationMessages[operation] || {
+    message: `Error performing ${operation}`,
+    details: ['Please check if your account has the necessary permissions.'],
+  };
+
+  return {
+    message: operationInfo.message,
+    messageType: 'warning',
+    details: [
+      {
+        title: 'Details',
+        items: operationInfo.details.map((detail, index) => ({
+          id: index + 1,
+          type: 'text',
+          text: detail,
+        })),
+      },
+    ],
+    ttl: 5000,
+  };
+}
+
+/**
+ * Handle database errors
+ * @param {Error} error - The error object
+ * @param {string} operation - Database operation name
+ * @param {Object} context - Additional context
+ */
+function handleDatabaseError(error, operation, context = {}) {
+  logger.error(`Database operation failed: ${operation}`, {
+    operation,
+    errorMessage: error.message,
+    errorStack: error.stack,
+    ...context,
+  });
+
+  return {
+    successful: false,
+    returnMessage: {
+      message: 'Database operation failed',
+      messageType: 'warning',
+      ttl: 5000,
+    },
+  };
+}
+
+/**
+ * Wrap async route handlers to catch errors
+ * Prevents unhandled promise rejections
+ * @param {Function} fn - Async route handler
+ * @returns {Function} Wrapped handler
+ */
+function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+
+/**
+ * Express error handling middleware
+ * Should be added after all routes
+ * @param {Error} err - Error object
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {Function} next - Express next function (required by Express signature)
+ */
+function errorMiddleware(err, req, res, next) { // eslint-disable-line no-unused-vars
+  const platform = req.platform || req.query?.platform || 'unknown';
+  const operation = req.route?.path || 'unknown';
+
+  logger.error('Request failed', {
+    platform,
+    operation,
+    method: req.method,
+    path: req.path,
+    statusCode: err.statusCode || 500,
+    error: err,
+    correlationId: req.correlationId,
+  });
+
+  // Don't expose internal errors in production
+  const message = process.env.NODE_ENV === 'production' 
+    ? 'An internal error occurred'
+    : err.message;
+
+  res.status(err.statusCode || 500).json({
+    successful: false,
+    returnMessage: {
+      message,
+      messageType: 'error',
+      ttl: 5000,
+    },
+  });
+}
+
+module.exports = {
+  handleApiError,
+  handleDatabaseError,
+  asyncHandler,
+  errorMiddleware,
+  getOperationErrorMessage,
+};
+

package/lib/jwt.js

@@ -1,4 +1,5 @@
 const { sign, verify } = require('jsonwebtoken');
+const logger = require('./logger');
 
 function generateJwt(data) {
   return sign(data, process.env.APP_SERVER_SECRET_KEY, { expiresIn: '120y' })
@@ -8,6 +9,7 @@ function decodeJwt(token) {
   try {
     return verify(token, process.env.APP_SERVER_SECRET_KEY);
   } catch (e) {
+    logger.error('Error decoding JWT', { stack: e.stack });
     return null;
   }
 }

package/lib/logger.js

@@ -0,0 +1,190 @@
+const util = require('util');
+
+/**
+ * Logger levels
+ */
+const LOG_LEVELS = {
+  ERROR: 0,
+  WARN: 1,
+  INFO: 2,
+  DEBUG: 3,
+};
+
+/**
+ * Color codes for terminal output
+ */
+const COLORS = {
+  ERROR: '\x1b[31m', // Red
+  WARN: '\x1b[33m',  // Yellow
+  INFO: '\x1b[36m',  // Cyan
+  DEBUG: '\x1b[90m', // Gray
+  RESET: '\x1b[0m',
+};
+
+class Logger {
+  constructor(options = {}) {
+    this.level = this._getLogLevel(options.level || process.env.LOG_LEVEL || 'INFO');
+    this.isProd = process.env.NODE_ENV === 'production';
+    this.enableColors = !this.isProd && process.stdout.isTTY;
+  }
+
+  _getLogLevel(levelName) {
+    const upperLevel = levelName.toUpperCase();
+    return LOG_LEVELS[upperLevel] !== undefined ? LOG_LEVELS[upperLevel] : LOG_LEVELS.INFO;
+  }
+
+  _shouldLog(level) {
+    return LOG_LEVELS[level] <= this.level;
+  }
+
+  _formatMessage(level, message, context = {}) {
+    const timestamp = new Date().toISOString();
+    
+    if (this.isProd) {
+      // Production: JSON format for log aggregation tools
+      return JSON.stringify({
+        timestamp,
+        level,
+        message,
+        ...context,
+      });
+    } else {
+      // Development: Human-readable format with colors
+      const color = this.enableColors ? COLORS[level] : '';
+      const reset = this.enableColors ? COLORS.RESET : '';
+      const contextStr = Object.keys(context).length > 0 
+        ? '\n' + util.inspect(context, { depth: 4, colors: this.enableColors })
+        : '';
+      
+      return `${color}[${timestamp}] [${level}]${reset} ${message}${contextStr}`;
+    }
+  }
+
+  _log(level, message, context = {}) {
+    if (!this._shouldLog(level)) {
+      return;
+    }
+
+    const formattedMessage = this._formatMessage(level, message, context);
+    
+    if (level === 'ERROR' || level === 'WARN') {
+      console.error(formattedMessage);
+    } else {
+      console.log(formattedMessage);
+    }
+  }
+
+  /**
+   * Log error level messages
+   * @param {string} message - Log message
+   * @param {Object} context - Additional context (error, stack, platform, etc.)
+   */
+  error(message, context = {}) {
+    // If context has an error object, extract useful information
+    let enrichedContext = context;
+    if (context.error instanceof Error) {
+      const { error, ...rest } = context;
+      enrichedContext = {
+        ...rest,
+        errorMessage: error.message,
+        errorStack: error.stack,
+        errorResponse: error.response?.data,
+        errorStatus: error.response?.status,
+      };
+    }
+    
+    this._log('ERROR', message, enrichedContext);
+  }
+
+  /**
+   * Log warning level messages
+   * @param {string} message - Log message
+   * @param {Object} context - Additional context
+   */
+  warn(message, context = {}) {
+    this._log('WARN', message, context);
+  }
+
+  /**
+   * Log info level messages
+   * @param {string} message - Log message
+   * @param {Object} context - Additional context
+   */
+  info(message, context = {}) {
+    this._log('INFO', message, context);
+  }
+
+  /**
+   * Log debug level messages
+   * @param {string} message - Log message
+   * @param {Object} context - Additional context
+   */
+  debug(message, context = {}) {
+    this._log('DEBUG', message, context);
+  }
+
+  /**
+   * Create a child logger with default context
+   * Useful for adding request-specific or module-specific context
+   * @param {Object} defaultContext - Context to include in all logs
+   * @returns {Object} Child logger with bound context
+   */
+  child(defaultContext = {}) {
+    return {
+      error: (message, context = {}) => this.error(message, { ...defaultContext, ...context }),
+      warn: (message, context = {}) => this.warn(message, { ...defaultContext, ...context }),
+      info: (message, context = {}) => this.info(message, { ...defaultContext, ...context }),
+      debug: (message, context = {}) => this.debug(message, { ...defaultContext, ...context }),
+      child: (additionalContext) => this.child({ ...defaultContext, ...additionalContext }),
+    };
+  }
+
+  /**
+   * Log API request/response for debugging
+   * @param {Object} options - Request details
+   */
+  logApiRequest({ method, url, status, duration, platform, error }) {
+    const context = {
+      method,
+      url,
+      status,
+      duration: duration ? `${duration}ms` : undefined,
+      platform,
+    };
+
+    if (error) {
+      this.error('API request failed', { ...context, error });
+    } else if (status >= 400) {
+      this.warn('API request returned error status', context);
+    } else {
+      this.debug('API request completed', context);
+    }
+  }
+
+  /**
+   * Log database query for debugging
+   * @param {Object} options - Query details
+   */
+  logDatabaseQuery({ operation, table, duration, error }) {
+    const context = {
+      operation,
+      table,
+      duration: duration ? `${duration}ms` : undefined,
+    };
+
+    if (error) {
+      this.error('Database query failed', { ...context, error });
+    } else {
+      this.debug('Database query completed', context);
+    }
+  }
+}
+
+// Create singleton instance
+const logger = new Logger();
+
+// Export both the class and instance
+module.exports = logger;
+module.exports.Logger = Logger;
+module.exports.LOG_LEVELS = LOG_LEVELS;
+

package/lib/oauth.js

@@ -3,7 +3,8 @@ const ClientOAuth2 = require('client-oauth2');
 const moment = require('moment');
 const { UserModel } = require('../models/userModel');
 const connectorRegistry = require('../connector/registry');
-
+const logger = require('./logger');
+const { handleDatabaseError } = require('./errorHandler');
 // 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 }) {
@@ -46,7 +47,7 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
                         overwrite: false
                     }
                 );
-                console.log('lock created')
+                logger.info('lock created')
             } catch (e) {
                 // If creation failed due to condition, a lock exists
                 if (e.name === 'ConditionalCheckFailedException' || e.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
@@ -54,7 +55,7 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
                     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.')
+                            logger.info('lock expired.')
                             await lock.delete();
                             newLock = await Lock.create(
                                 {
@@ -90,7 +91,7 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
                             throw new Error('Token lock timeout');
                         }
                         user = await UserModel.findByPk(user.id);
-                        console.log('locked. bypass')
+                        logger.info('locked. bypass')
                         return user;
                     }
                 } else {
@@ -100,20 +101,25 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
             try {
                 const startRefreshTime = moment();
                 const token = oauthApp.createToken(user.accessToken, user.refreshToken);
-                console.log('token refreshing...')
+            logger.info('token refreshing...')
                 const { accessToken, refreshToken, expires } = await token.refresh();
                 user.accessToken = accessToken;
                 user.refreshToken = refreshToken;
                 user.tokenExpiry = expires;
+            try {
                 await user.save();
+            }
+            catch (error) {
+                return handleDatabaseError(error, 'Error saving user');
+            }
                 if (newLock) {
                     const deletionStartTime = moment();
                     await newLock.delete();
                     const deletionEndTime = moment();
-                    console.log(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`)
+                logger.info(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`)
                 }
                 const endRefreshTime = moment();
-                console.log(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`)
+            logger.info(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`)
             }
             catch (e) {
                 console.log('token refreshing failed', e.stack)
@@ -124,14 +130,19 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
         }
         // case: run withou token refresh lock
         else {
-            console.log('token refreshing...')
+            logger.info('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')
+            try {
+                await user.save();
+            }
+            catch (error) {
+                return handleDatabaseError(error, 'Error saving user');
+            }
+            logger.info('token refreshing finished')
         }
 
     }

package/lib/ringcentral.js

@@ -52,8 +52,6 @@ class RingCentral {
     const {
       expires_in,
       refresh_token_expires_in,
-      scope,
-      endpoint_id, // do no save this field into db to reduce db size
       ...token
     } = await response.json();
     return {
@@ -79,8 +77,6 @@ class RingCentral {
     const {
       expires_in,
       refresh_token_expires_in,
-      scope,
-      endpoint_id, // do no save this field into db to reduce db size
       ...newToken
     } = await response.json();
     return {
@@ -164,10 +160,6 @@ class RingCentral {
       },
     }, token);
     const {
-      uri,
-      creationTime,
-      deliveryMode,
-      status, // do no save those field into db to reduce db size
       ...subscription
     } = await response.json();
     return subscription;
@@ -226,7 +218,7 @@ class RingCentral {
     return response.json();
   }
 
-  async getCallLogData({ extensionId = '~', token, timezone, timeFrom, timeTo }) {
+  async getCallLogData({ extensionId = '~', token, timeFrom, timeTo }) {
     let pageStart = 1;
     let isFinalPage = false;
     let callLogResponse = null;
@@ -247,7 +239,7 @@ class RingCentral {
     }
     return result;
   }
-  async getSMSData({ extensionId = '~', token, timezone, timeFrom, timeTo }) {
+  async getSMSData({ extensionId = '~', token, timeFrom, timeTo }) {
     let pageStart = 1;
     let isFinalPage = false;
     let smsLogResponse = null;