hwj-common-lib/error.js

微信小程序云开发通用模块库，支持灵活的环境配置

/**
 * 通用错误处理模块
 * 提供标准化的错误类和错误处理机制
 */

// 基础错误类
class BaseError extends Error {
  constructor(message, code) {
    super(message);
    this.name = this.constructor.name;
    this.code = code;
    Error.captureStackTrace(this, this.constructor);
  }
}

// 验证错误
class ValidationError extends BaseError {
  constructor(message, field = null) {
    super(message, 400);
    this.field = field;
  }
}

// 业务错误
class BusinessError extends BaseError {
  constructor(message, businessCode = null) {
    super(message, 400);
    this.businessCode = businessCode;
  }
}

// 登录错误
class LoginError extends BaseError {
  constructor(message) {
    super(message, 401);
  }
}

// Token错误
class TokenError extends BaseError {
  constructor(message) {
    super(message, 401);
  }
}

// 设备错误
class DeviceError extends BaseError {
  constructor(message, deviceInfo = null) {
    super(message, 403);
    this.deviceInfo = deviceInfo;
  }
}

// 数据库错误
class DatabaseError extends BaseError {
  constructor(message, operation = null) {
    super(message, 500);
    this.operation = operation;
  }
}

// 权限错误
class PermissionError extends BaseError {
  constructor(message, requiredPermission = null) {
    super(message, 403);
    this.requiredPermission = requiredPermission;
  }
}

// 资源不存在错误
class NotFoundError extends BaseError {
  constructor(message, resource = null) {
    super(message, 404);
    this.resource = resource;
  }
}

// 配额错误
class QuotaError extends BaseError {
  constructor(message, limit = null) {
    super(message, 429);
    this.limit = limit;
  }
}

/**
 * 格式化错误对象为标准响应
 * @param {Error} error - 错误对象
 * @returns {Object} 格式化的错误响应
 */
function formatError(error) {
  // 基础信息
  const response = {
    success: false,
    code: error.code || 500,
    message: error.message || '未知错误'
  };
  
  // 添加错误名称
  response.name = error.name;
  
  // 针对不同类型错误添加额外信息
  if (error instanceof ValidationError && error.field) {
    response.field = error.field;
  } else if (error instanceof BusinessError && error.businessCode) {
    response.businessCode = error.businessCode;
  } else if (error instanceof DeviceError && error.deviceInfo) {
    response.deviceInfo = error.deviceInfo;
  } else if (error instanceof DatabaseError && error.operation) {
    response.operation = error.operation;
  } else if (error instanceof PermissionError && error.requiredPermission) {
    response.requiredPermission = error.requiredPermission;
  } else if (error instanceof NotFoundError && error.resource) {
    response.resource = error.resource;
  } else if (error instanceof QuotaError && error.limit) {
    response.limit = error.limit;
  }
  
  return response;
}

/**
 * 错误处理函数
 * @param {Error} error - 错误对象
 * @returns {Object} 格式化的错误响应
 */
function errorHandler(error) {
  console.error('错误信息:', error.message);
  console.error('错误堆栈:', error.stack);
  
  // 区分自定义错误和系统错误
  if (error instanceof BaseError) {
    return formatError(error);
  }
  
  // 根据错误类型映射为自定义错误
  switch(error.name) {
    case 'ValidationError':
      return formatError(new ValidationError(error.message));
    case 'BusinessError':
      return formatError(new BusinessError(error.message));
    case 'LoginError':
      return formatError(new LoginError(error.message));
    case 'TokenError':
      return formatError(new TokenError(error.message));
    case 'DeviceError':
      return formatError(new DeviceError(error.message));
    case 'DatabaseError':
      return formatError(new DatabaseError(error.message));
    case 'PermissionError':
      return formatError(new PermissionError(error.message));
    case 'NotFoundError':
      return formatError(new NotFoundError(error.message));
    case 'QuotaError':
      return formatError(new QuotaError(error.message));
    default:
      // 处理系统错误
      if (error.code === 'permission.denied') {
        return formatError(new PermissionError('权限不足，无法执行此操作'));
      } else if (error.code === 'database.queryFailed') {
        return formatError(new DatabaseError('数据库查询失败'));
      } else if (error.code === 'database.updateFailed') {
        return formatError(new DatabaseError('数据库更新失败'));
      } else {
        return {
          success: false,
          code: 500,
          message: '服务器内部错误',
          detail: error.message
        };
      }
  }
}

module.exports = {
  ValidationError,
  BusinessError,
  LoginError,
  TokenError,
  DeviceError,
  DatabaseError,
  PermissionError,
  NotFoundError,
  QuotaError,
  errorHandler
};