@app-connect/core 1.7.37 → 1.7.38

package/lib/errorHandler.js

@@ -1,218 +0,0 @@
-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.'],
-    },
-    createAppointment: {
-      message: 'Error creating appointment',
-      details: ['Please check if your account has permission to CREATE appointments. or All attendees have email address.'],
-    },
-    updateAppointment: {
-      message: 'Error updating appointment',
-      details: [`Please check if the appointment entity still exists on ${platform} and your account has permission to EDIT appointments. or All attendees have email address.`],
-    },
-    getAppointment: {
-      message: 'Error getting appointment',
-      details: ['Please check if your account has permission to GET appointments.'],
-    },
-  };
-
-  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,18 +0,0 @@
-const { sign, verify } = require('jsonwebtoken');
-const logger = require('./logger');
-
-function generateJwt(data) {
-  return sign(data, process.env.APP_SERVER_SECRET_KEY, { expiresIn: '2w' })
-}
-
-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;
-  }
-}
-
-exports.generateJwt = generateJwt;
-exports.decodeJwt = decodeJwt;

package/lib/logger.js

@@ -1,190 +0,0 @@
-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/ringcentral.js

@@ -1,267 +0,0 @@
-
-const fetch = require('node-fetch');
-
-const DEFAULT_RENEW_HANDICAP_MS = 60 * 1000; // 1 minute
-
-function stringifyQuery(query) {
-  const queryParams = new URLSearchParams(query);
-  return queryParams.toString();
-}
-
-const REFRESH_RENEW_HANDICAP_MS = 10 * 1000; // 10s
-function isRefreshTokenValid(token, handicap = REFRESH_RENEW_HANDICAP_MS) {
-  const expireTime = token.refresh_token_expire_time;
-  return expireTime - handicap > Date.now();
-}
-
-function isAccessTokenValid(token, handicap = DEFAULT_RENEW_HANDICAP_MS) {
-  const expireTime = token.expire_time;
-  return expireTime - handicap > Date.now();
-}
-
-class RingCentral {
-  constructor(options) {
-    this._options = options;
-  }
-
-  loginUrl({
-    state,
-  }) {
-    const query = {
-      response_type: 'code',
-      redirect_uri: this._options.redirectUri,
-      client_id: this._options.clientId,
-      response_hint: 'brand_id contracted_country_code',
-    };
-    if (state) {
-      query.state = state;
-    }
-    return `${this._options.server}/restapi/oauth/authorize?${stringifyQuery(query)}`;
-  }
-
-  async generateToken({ code }) {
-    const body = {
-      code,
-      grant_type: 'authorization_code',
-      redirect_uri: this._options.redirectUri,
-    };
-    const response = await this._tokenRequest('/restapi/oauth/token', body);
-    if (Number.parseInt(response.status, 10) >= 400) {
-      throw new Error('Generate Token error', response.status);
-    }
-    const {
-      expires_in,
-      refresh_token_expires_in,
-      ...token
-    } = await response.json();
-    return {
-      ...token,
-      expire_time: Date.now() + parseInt(expires_in, 10) * 1000,
-      refresh_token_expire_time: Date.now() + parseInt(refresh_token_expires_in, 10) * 1000,
-    };
-  }
-
-  async refreshToken(token) {
-    const body = {
-      grant_type: 'refresh_token',
-      refresh_token: token.refresh_token,
-      access_token_ttl: token.expires_in,
-      refresh_token_ttl: token.refresh_token_expires_in,
-    };
-    const response = await this._tokenRequest('/restapi/oauth/token', body);
-    if (Number.parseInt(response.status, 10) >= 400) {
-      const error = new Error('Refresh Token error', response.status);
-      error.response = response;
-      throw error;
-    }
-    const {
-      expires_in,
-      refresh_token_expires_in,
-      ...newToken
-    } = await response.json();
-    return {
-      ...newToken,
-      expire_time: Date.now() + parseInt(expires_in, 10) * 1000,
-      refresh_token_expire_time: Date.now() + parseInt(refresh_token_expires_in, 10) * 1000,
-    }
-  }
-
-  async revokeToken(token) {
-    const body = {
-      token: token.access_token,
-    };
-    const response = await this._tokenRequest('/restapi/oauth/revoke', body);
-    if (Number.parseInt(response.status, 10) >= 400) {
-      throw new Error('Revoke Token error', response.status);
-    }
-  }
-
-  async _tokenRequest(path, body) {
-    const authorization = `${this._options.clientId}:${this._options.clientSecret}`;
-    const response = await fetch(
-      `${this._options.server}${path}`, {
-      method: 'POST',
-      body: stringifyQuery(body),
-      headers: {
-        'Accept': 'application/json',
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'Authorization': `Basic ${Buffer.from(authorization).toString('base64')}`
-      },
-    }
-    );
-    return response;
-  }
-
-  async request({
-    server = this._options.server,
-    path,
-    query,
-    body,
-    method,
-    accept = 'application/json',
-  }, token) {
-    let uri = `${server}${path}`;
-    if (query) {
-      uri = uri + (uri.includes('?') ? '&' : '?') + stringifyQuery(query);
-    }
-    const response = await fetch(uri, {
-      method,
-      body: body ? JSON.stringify(body) : body,
-      headers: {
-        'Accept': accept,
-        'Content-Type': 'application/json',
-        'Authorization': `${token.token_type} ${token.access_token}`,
-      },
-    });
-    if (Number.parseInt(response.status, 10) >= 400) {
-      const error = new Error(`request data error ${response.status}`);
-      const errorText = await response.text();
-      error.message = errorText;
-      error.response = response;
-      throw error;
-    }
-    return response;
-  }
-
-  async createSubscription({
-    eventFilters,
-    webhookUri,
-  }, token) {
-    const response = await this.request({
-      method: 'POST',
-      path: '/restapi/v1.0/subscription',
-      body: {
-        eventFilters,
-        deliveryMode: {
-          transportType: 'WebHook',
-          address: webhookUri,
-        },
-        expiresIn: 7 * 24 * 3600, // 7 days
-      },
-    }, token);
-    const {
-      ...subscription
-    } = await response.json();
-    return subscription;
-  }
-
-  async getExtensionInfo(extensionId, token) {
-    const response = await this.request({
-      method: 'GET',
-      path: `/restapi/v1.0/account/~/extension/${extensionId}`,
-    }, token);
-    return response.json();
-  }
-
-  async getAccountInfo(token) {
-    const response = await this.request({
-      method: 'GET',
-      path: `/restapi/v1.0/account/~`,
-    }, token);
-    return response.json();
-  }
-
-  async getCallsAggregationData({ token, timezone, timeFrom, timeTo, groupBy }) {
-    const body = {
-      grouping: {
-        groupBy
-      },
-      timeSettings: {
-        timeZone: timezone,
-        timeRange: {
-          timeFrom: timeFrom,
-          timeTo: timeTo
-        }
-      },
-      responseOptions: {
-        counters: {
-          callsByDirection: {
-            aggregationType: "Sum"
-          },
-          callsByResponse: {
-            aggregationType: "Sum"
-          }
-        },
-        timers: {
-          allCallsDuration: {
-            aggregationType: "Sum"
-          }
-        }
-      }
-    }
-    const response = await this.request({
-      method: 'POST',
-      path: `/analytics/calls/v1/accounts/~/aggregation/fetch`,
-      body,
-      accept: 'application/json'
-    }, token);
-    return response.json();
-  }
-
-  async getCallLogData({ extensionId = '~', token, timeFrom, timeTo }) {
-    let pageStart = 1;
-    let isFinalPage = false;
-    let callLogResponse = null;
-    let result = { records: [] };
-    while (!isFinalPage) {
-      callLogResponse = await this.request({
-        method: 'GET',
-        path: `/restapi/v1.0/account/~/extension/${extensionId}/call-log?dateFrom=${timeFrom}&dateTo=${timeTo}&page=${pageStart}&view=Simple&perPage=1000`,
-      }, token);
-      const resultJson = await callLogResponse.json();
-      result.records.push(...resultJson.records);
-      if (resultJson.navigation?.nextPage) {
-        pageStart++;
-      }
-      else {
-        isFinalPage = true;
-      }
-    }
-    return result;
-  }
-  async getSMSData({ extensionId = '~', token, timeFrom, timeTo }) {
-    let pageStart = 1;
-    let isFinalPage = false;
-    let smsLogResponse = null;
-    let result = { records: [] };
-    while (!isFinalPage) {
-      smsLogResponse = await this.request({
-        method: 'GET',
-        path: `/restapi/v1.0/account/~/extension/${extensionId}/message-store?dateFrom=${timeFrom}&dateTo=${timeTo}&page=${pageStart}&perPage=100`,
-      }, token);
-      const resultJson = await smsLogResponse.json();
-      result.records.push(...resultJson.records);
-      if (resultJson.navigation?.nextPage) {
-        pageStart++;
-      }
-      else {
-        isFinalPage = true;
-      }
-    }
-    return result;
-  }
-}
-
-exports.RingCentral = RingCentral;
-exports.isRefreshTokenValid = isRefreshTokenValid;
-exports.isAccessTokenValid = isAccessTokenValid;