@app-connect/core 1.7.36 → 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/migrateCallLogsSchema.js

@@ -1,237 +0,0 @@
-const Sequelize = require('sequelize');
-
-const CALL_LOGS_TABLE = 'callLogs';
-const HASHED_EXTENSION_ID_COLUMN = 'hashedExtensionId';
-const CALL_LOG_IDENTITY_PK_COLUMNS = ['id', 'sessionId', 'extensionNumber', HASHED_EXTENSION_ID_COLUMN];
-
-function findColumnKey(tableDescription, name) {
-    const lower = name.toLowerCase();
-    return Object.keys(tableDescription).find((k) => k.toLowerCase() === lower);
-}
-
-async function fetchCallLogsCreateSqlSqlite(sequelize, options = {}) {
-    const rows = await sequelize.query(
-        "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'callLogs'",
-        { type: Sequelize.QueryTypes.SELECT, ...options },
-    );
-    return rows[0]?.sql ?? null;
-}
-
-function callLogsCreateSqlClaimsPkColumns(createSql, columns) {
-    if (!createSql || typeof createSql !== 'string') {
-        return false;
-    }
-    const pkRegex = /PRIMARY\s+KEY\s*\(([^)]+)\)/gi;
-    let m;
-    while ((m = pkRegex.exec(createSql)) !== null) {
-        const pkColumns = m[1]
-            .split(',')
-            .map((column) => column.replace(/["'`\[\]\s]/g, '').toLowerCase());
-        if (columns.every((column) => pkColumns.includes(column.toLowerCase()))) {
-            return true;
-        }
-    }
-    return false;
-}
-
-function callLogsCreateSqlClaimsExtensionPk(createSql) {
-    return callLogsCreateSqlClaimsPkColumns(createSql, ['extensionNumber']);
-}
-
-async function sqliteCallLogsPkIncludesExtension(sequelize, options = {}) {
-    const sql = await fetchCallLogsCreateSqlSqlite(sequelize, options);
-    return callLogsCreateSqlClaimsExtensionPk(sql);
-}
-
-async function sqliteCallLogsPkIncludesHashedExtension(sequelize, options = {}) {
-    const sql = await fetchCallLogsCreateSqlSqlite(sequelize, options);
-    return callLogsCreateSqlClaimsPkColumns(sql, CALL_LOG_IDENTITY_PK_COLUMNS);
-}
-
-async function describeCallLogsTable(sequelize, options = {}) {
-    return sequelize.getQueryInterface().describeTable(CALL_LOGS_TABLE, options);
-}
-
-/**
- * SQLite cannot change composite PK via Sequelize addConstraint (it appends a second PRIMARY KEY).
- * Rebuild the table with the current call-log identity primary key and copy rows.
- */
-async function migrateCallLogsIdentitySqlite(sequelize, transaction) {
-    const qg = sequelize.getQueryInterface().queryGenerator;
-    const qi = sequelize.getQueryInterface();
-    const q = (id) => qg.quoteIdentifier(id);
-    const tmpName = `callLogs_mig_legacy_${Date.now()}`;
-    const mainTableSql = qg.quoteTable({ tableName: CALL_LOGS_TABLE });
-    const tmpTableSql = qg.quoteTable({ tableName: tmpName });
-
-    await sequelize.query(
-        `ALTER TABLE ${mainTableSql} RENAME TO ${qg.quoteIdentifier(tmpName)};`,
-        { transaction },
-    );
-
-    await sequelize.query(
-        `
-    CREATE TABLE ${mainTableSql} (
-      ${q('id')} VARCHAR(255) NOT NULL,
-      ${q('sessionId')} VARCHAR(255) NOT NULL,
-      ${q('extensionNumber')} VARCHAR(255) NOT NULL DEFAULT '',
-      ${q(HASHED_EXTENSION_ID_COLUMN)} VARCHAR(255) NOT NULL DEFAULT '',
-      ${q('platform')} VARCHAR(255),
-      ${q('thirdPartyLogId')} VARCHAR(255),
-      ${q('userId')} VARCHAR(255),
-      ${q('contactId')} VARCHAR(255),
-      ${q('createdAt')} DATETIME NOT NULL,
-      ${q('updatedAt')} DATETIME NOT NULL,
-      PRIMARY KEY (${CALL_LOG_IDENTITY_PK_COLUMNS.map(q).join(', ')})
-    );
-    `,
-        { transaction },
-    );
-
-    const oldDesc = await qi.describeTable(tmpName, { transaction });
-
-    const targetCols = [
-        'id',
-        'sessionId',
-        'extensionNumber',
-        HASHED_EXTENSION_ID_COLUMN,
-        'platform',
-        'thirdPartyLogId',
-        'userId',
-        'contactId',
-        'createdAt',
-        'updatedAt',
-    ];
-
-    const missingRequired = targetCols.filter(
-        (c) => findColumnKey(oldDesc, c) == null && c !== 'extensionNumber' && c !== HASHED_EXTENSION_ID_COLUMN,
-    );
-    if (missingRequired.length) {
-        throw new Error(
-            `unexpected callLogs schema before migration (missing columns: ${missingRequired.join(', ')})`,
-        );
-    }
-
-    const insertCols = targetCols.map(q).join(', ');
-    const selectExprs = targetCols
-        .map((col) => {
-            const key = findColumnKey(oldDesc, col);
-            if (key != null) {
-                return q(key);
-            }
-            return `CAST('' AS VARCHAR(255))`;
-        })
-        .join(', ');
-
-    await sequelize.query(
-        `INSERT INTO ${mainTableSql} (${insertCols}) SELECT ${selectExprs} FROM ${tmpTableSql};`,
-        { transaction },
-    );
-
-    await sequelize.query(`DROP TABLE ${tmpTableSql};`, { transaction });
-}
-
-async function migrateCallLogsExtensionNumberSqlite(sequelize, transaction) {
-    return migrateCallLogsIdentitySqlite(sequelize, transaction);
-}
-
-async function getPostgresPrimaryKeyConstraint(sequelize, options = {}) {
-    const constraints = await sequelize.query(
-        `
-        SELECT tc.constraint_name AS "constraintName"
-        FROM information_schema.table_constraints tc
-        WHERE tc.table_name = :tableName
-          AND tc.constraint_type = 'PRIMARY KEY'
-        LIMIT 1
-        `,
-        {
-            type: Sequelize.QueryTypes.SELECT,
-            replacements: { tableName: CALL_LOGS_TABLE },
-            ...options,
-        },
-    );
-    return constraints[0]?.constraintName ?? null;
-}
-
-async function postgresCallLogsPkIncludesHashedExtension(sequelize, options = {}) {
-    const pkConstraintName = await getPostgresPrimaryKeyConstraint(sequelize, options);
-    if (!pkConstraintName) {
-        return false;
-    }
-    const rows = await sequelize.query(
-        `
-        SELECT kcu.column_name AS "columnName"
-        FROM information_schema.key_column_usage kcu
-        WHERE kcu.table_name = :tableName
-          AND kcu.constraint_name = :constraintName
-        ORDER BY kcu.ordinal_position
-        `,
-        {
-            type: Sequelize.QueryTypes.SELECT,
-            replacements: { tableName: CALL_LOGS_TABLE, constraintName: pkConstraintName },
-            ...options,
-        },
-    );
-    const pkColumns = rows.map((row) => row.columnName.toLowerCase());
-    return CALL_LOG_IDENTITY_PK_COLUMNS.every((column) => pkColumns.includes(column.toLowerCase()));
-}
-
-async function migrateCallLogsIdentityPostgres(sequelize, transaction) {
-    const qi = sequelize.getQueryInterface();
-    const qg = qi.queryGenerator;
-    const table = qg.quoteTable({ tableName: CALL_LOGS_TABLE });
-    const pkConstraintName = await getPostgresPrimaryKeyConstraint(sequelize, { transaction });
-    if (pkConstraintName) {
-        await sequelize.query(
-            `ALTER TABLE ${table} DROP CONSTRAINT ${qg.quoteIdentifier(pkConstraintName)};`,
-            { transaction },
-        );
-    }
-    await sequelize.query(
-        `ALTER TABLE ${table} ADD PRIMARY KEY (${CALL_LOG_IDENTITY_PK_COLUMNS.map((column) => qg.quoteIdentifier(column)).join(', ')});`,
-        { transaction },
-    );
-}
-
-async function ensureCallLogsHashedExtensionIdSchema(sequelize) {
-    const qi = sequelize.getQueryInterface();
-    const dialect = sequelize.getDialect();
-    let desc = await describeCallLogsTable(sequelize);
-
-    if (findColumnKey(desc, HASHED_EXTENSION_ID_COLUMN) == null) {
-        await qi.addColumn(CALL_LOGS_TABLE, HASHED_EXTENSION_ID_COLUMN, {
-            type: Sequelize.STRING,
-            allowNull: false,
-            defaultValue: '',
-        });
-        desc = await describeCallLogsTable(sequelize);
-    }
-
-    if (dialect === 'sqlite') {
-        const hasIdentityPk = await sqliteCallLogsPkIncludesHashedExtension(sequelize);
-        if (!hasIdentityPk) {
-            await sequelize.transaction(async (transaction) => {
-                await migrateCallLogsIdentitySqlite(sequelize, transaction);
-            });
-        }
-        return;
-    }
-
-    if (dialect === 'postgres') {
-        const hasIdentityPk = await postgresCallLogsPkIncludesHashedExtension(sequelize);
-        if (!hasIdentityPk) {
-            await sequelize.transaction(async (transaction) => {
-                await migrateCallLogsIdentityPostgres(sequelize, transaction);
-            });
-        }
-    }
-}
-
-module.exports = {
-    findColumnKey,
-    migrateCallLogsExtensionNumberSqlite,
-    migrateCallLogsIdentitySqlite,
-    sqliteCallLogsPkIncludesExtension,
-    sqliteCallLogsPkIncludesHashedExtension,
-    ensureCallLogsHashedExtensionIdSchema,
-};