sync-upstream
Version:
A tool for synchronizing code with upstream repositories with incremental updates and parallel processing.
233 lines (232 loc) • 7.78 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationError = exports.TimeoutError = exports.PermissionError = exports.AuthenticationError = exports.ConflictError = exports.SyncProcessError = exports.UserCancelError = exports.NetworkError = exports.FsError = exports.GitError = exports.ConfigError = exports.SyncError = exports.ErrorSeverity = exports.ErrorType = void 0;
exports.handleError = handleError;
const chalk_1 = __importDefault(require("chalk"));
const logger_1 = require("./logger");
// 错误类型枚举
var ErrorType;
(function (ErrorType) {
ErrorType["CONFIG"] = "CONFIG_ERROR";
ErrorType["GIT"] = "GIT_ERROR";
ErrorType["FS"] = "FS_ERROR";
ErrorType["NETWORK"] = "NETWORK_ERROR";
ErrorType["USER_CANCEL"] = "USER_CANCEL";
ErrorType["SYNC_PROCESS"] = "SYNC_PROCESS_ERROR";
ErrorType["CONFLICT"] = "CONFLICT_ERROR";
ErrorType["AUTHENTICATION"] = "AUTH_ERROR";
ErrorType["PERMISSION"] = "PERMISSION_ERROR";
ErrorType["TIMEOUT"] = "TIMEOUT_ERROR";
ErrorType["VALIDATION"] = "VALIDATION_ERROR";
})(ErrorType || (exports.ErrorType = ErrorType = {}));
// 错误严重程度枚举
var ErrorSeverity;
(function (ErrorSeverity) {
ErrorSeverity["INFO"] = "info";
ErrorSeverity["WARNING"] = "warning";
ErrorSeverity["ERROR"] = "error";
ErrorSeverity["CRITICAL"] = "critical";
})(ErrorSeverity || (exports.ErrorSeverity = ErrorSeverity = {}));
/**
* 自定义错误基类
*/
class SyncError extends Error {
constructor(message, code, severity = ErrorSeverity.ERROR, originalError, context) {
super(message);
this.code = code;
this.severity = severity;
this.originalError = originalError;
this.timestamp = new Date();
this.context = context;
this.name = this.constructor.name;
// 修复继承链
Object.setPrototypeOf(this, new.target.prototype);
}
/**
* 显示友好的错误信息
*/
display() {
const severityColor = this.getSeverityColor();
console.error(severityColor(`
❌ ${this.name} (${this.code}):`));
console.error(severityColor(this.message));
if (this.context) {
console.error(chalk_1.default.blue('错误上下文:'));
console.error(chalk_1.default.blue(JSON.stringify(this.context, null, 2)));
}
if (this.originalError) {
console.error(chalk_1.default.yellow('原始错误:'));
console.error(chalk_1.default.yellow(this.originalError.message));
// 记录完整错误栈到日志
logger_1.logger.error(`原始错误栈: ${this.originalError.stack || '无'}`);
}
// 记录错误到日志
this.logError();
}
/**
* 根据错误严重程度获取对应的颜色
*/
getSeverityColor() {
switch (this.severity) {
case ErrorSeverity.INFO:
return chalk_1.default.blue;
case ErrorSeverity.WARNING:
return chalk_1.default.yellow;
case ErrorSeverity.ERROR:
return chalk_1.default.red;
case ErrorSeverity.CRITICAL:
return chalk_1.default.bold.red;
default:
return chalk_1.default.red;
}
}
/**
* 记录错误到日志
*/
logError() {
const errorData = {
name: this.name,
code: this.code,
message: this.message,
severity: this.severity,
timestamp: this.timestamp.toISOString(),
context: this.context,
originalError: this.originalError?.message,
};
switch (this.severity) {
case ErrorSeverity.INFO:
logger_1.logger.info(JSON.stringify(errorData));
break;
case ErrorSeverity.WARNING:
logger_1.logger.warn(JSON.stringify(errorData));
break;
case ErrorSeverity.ERROR:
logger_1.logger.error(JSON.stringify(errorData));
break;
case ErrorSeverity.CRITICAL:
logger_1.logger.error(chalk_1.default.bold.red(JSON.stringify(errorData)));
break;
}
}
}
exports.SyncError = SyncError;
/**
* 配置错误
*/
class ConfigError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.CONFIG, ErrorSeverity.ERROR, originalError, context);
}
}
exports.ConfigError = ConfigError;
/**
* Git 错误
*/
class GitError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.GIT, ErrorSeverity.ERROR, originalError, context);
}
}
exports.GitError = GitError;
/**
* 文件系统错误
*/
class FsError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.FS, ErrorSeverity.ERROR, originalError, context);
}
}
exports.FsError = FsError;
/**
* 网络错误
*/
class NetworkError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.NETWORK, ErrorSeverity.WARNING, originalError, context);
}
}
exports.NetworkError = NetworkError;
/**
* 用户取消操作错误
*/
class UserCancelError extends SyncError {
constructor(message = '用户取消了操作', context) {
super(message, ErrorType.USER_CANCEL, ErrorSeverity.INFO, undefined, context);
}
}
exports.UserCancelError = UserCancelError;
/**
* 同步过程错误
*/
class SyncProcessError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.SYNC_PROCESS, ErrorSeverity.ERROR, originalError, context);
}
}
exports.SyncProcessError = SyncProcessError;
/**
* 冲突错误
*/
class ConflictError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.CONFLICT, ErrorSeverity.ERROR, originalError, context);
}
}
exports.ConflictError = ConflictError;
/**
* 认证错误
*/
class AuthenticationError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.AUTHENTICATION, ErrorSeverity.CRITICAL, originalError, context);
}
}
exports.AuthenticationError = AuthenticationError;
/**
* 权限错误
*/
class PermissionError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.PERMISSION, ErrorSeverity.ERROR, originalError, context);
}
}
exports.PermissionError = PermissionError;
/**
* 超时错误
*/
class TimeoutError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.TIMEOUT, ErrorSeverity.WARNING, originalError, context);
}
}
exports.TimeoutError = TimeoutError;
/**
* 验证错误
*/
class ValidationError extends SyncError {
constructor(message, originalError, context) {
super(message, ErrorType.VALIDATION, ErrorSeverity.WARNING, originalError, context);
}
}
exports.ValidationError = ValidationError;
/**
* 错误处理工具函数
*/
function handleError(error) {
if (error instanceof SyncError) {
error.display();
// 根据错误严重程度决定是否退出进程
if (error.severity === ErrorSeverity.CRITICAL) {
logger_1.logger.error('发生严重错误，程序将退出');
process.exit(1);
}
}
else {
const unknownError = new SyncProcessError('发生未知错误', error);
unknownError.display();
process.exit(1);
}
}