14528264067

Committed 18 Apr 2025 02:07AM UTC coverage: 21.133% (+10.1%) from 10.998%

Build # 14528264067

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5 from scobru/v2

V2

Run Details

105 of 604 branches covered (17.38%)

Branch coverage included in aggregate %.

45 of 131 new or added lines in 4 files covered. (34.35%)

5 existing lines in 1 file now uncovered.

339 of 1497 relevant lines covered (22.65%)

1.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

37.4

/src/utils/errorHandler.ts

import { log, logError } from "./logger";
import { LogLevel } from "../types/common";

/**
 * Tipi di errore che possono verificarsi nell'applicazione
 */
export enum ErrorType {
  AUTHENTICATION = "AuthenticationError",
  AUTHORIZATION = "AuthorizationError",
  VALIDATION = "ValidationError",
  NETWORK = "NetworkError",
  DATABASE = "DatabaseError",
  WALLET = "WalletError",
  DID = "DIDError",
  STORAGE = "StorageError",
  ENCRYPTION = "EncryptionError",
  SIGNATURE = "SignatureError",
  ENVIRONMENT = "EnvironmentError",
  SECURITY = "SecurityError",
  GUN = "GunError",
  STEALTH = "StealthError",
  WEBAUTHN = "WebAuthnError",
  PLUGIN = "PluginError",
  UNKNOWN = "UnknownError",
  CONNECTOR = "CONNECTOR",
  GENERAL = "GENERAL",
}

/**
 * Interfaccia standard per errori di Shogun
 */
export interface ShogunError {
  type: ErrorType;
  code: string;
  message: string;
  originalError?: Error | unknown;
  timestamp: number;
}

/**
 * Wrapper per standardizzare gli errori
 * @param type - Tipo di errore
 * @param code - Codice errore
 * @param message - Messaggio errore
 * @param originalError - Errore originale
 * @returns Un oggetto di errore strutturato
 */
export function createError(
  type: ErrorType,
  code: string,
  message: string,
  originalError?: Error | unknown
): ShogunError {
  return {
    type,
    code,
    message,
    originalError,
    timestamp: Date.now(),
  };
}

/**
 * Opzioni di configurazione per il gestore di errori
 */
export interface ErrorOptions {
  message?: string;
  throwError?: boolean;
  logError?: boolean;
  callback?: ErrorCallback;
}

/**
 * Tipo della funzione di callback per errori
 */
export type ErrorCallback = (error: any) => any;

/**
 * Risultato standardizzato per gestione errori
 */
export interface ErrorResult {
  success: boolean;
  message: string;
  error?: any;
}

/**
 * Funzione di utilità per gestire gli errori in modo consistente
 * @param error - L'errore da gestire
 * @param options - Opzioni di configurazione
 * @returns Risultato dell'operazione o il risultato della callback
 */
export function handleError(
  error: any,
  options: ErrorOptions = {}
): ErrorResult | any {
  // Impostazioni di default
  const {
    message = error instanceof Error ? error.message : String(error),
    throwError = false,
    logError = true,
    callback,
  } = options;

  // Log dell'errore se richiesto
  if (logError) {
    console.error(`[ERROR] ${message}`, error);
  }

  // Se è stata fornita una callback, la eseguiamo e restituiamo il suo risultato
  if (typeof callback === "function") {
    return callback(error);
  }

  // Se è richiesto di lanciare l'errore, lo lanciamo
  if (throwError) {
    if (error instanceof Error) {
      throw error;
    } else {
      throw new Error(message);
    }
  }

  // Altrimenti restituiamo un oggetto di risultato standard
  return {
    success: false,
    message,
    error,
  };
}

/**
 * Gestore centralizzato per errori
 */
export class ErrorHandler {
  private static errors: ShogunError[] = [];
  private static maxErrors: number = 100;
  private static listeners: Array<(error: ShogunError) => void> = [];

  /**
   * Gestisce un errore registrandolo e notificando gli ascoltatori
   * @param error - L'errore da gestire
   */
  static handleError(error: ShogunError): void {
    // Log l'errore
    logError(`[${error.type}] ${error.code}: ${error.message}`);

    // Conserva l'errore nella memoria
    this.errors.push(error);

    // Mantiene solo gli ultimi maxErrors
    if (this.errors.length > this.maxErrors) {
      this.errors = this.errors.slice(-this.maxErrors);
    }

    // Notifica gli ascoltatori
    this.notifyListeners(error);
  }

  /**
   * Gestisce un errore grezzo convertendolo in ShogunError
   * @param type - Tipo errore
   * @param code - Codice errore
   * @param message - Messaggio errore
   * @param originalError - Errore originale
   */
  static handle(
    type: ErrorType,
    code: string,
    message: string,
    originalError?: Error | unknown,
    logLevel: LogLevel = "error"
  ): ShogunError {
    // Create a formatted error message
    const finalMessage = originalError
      ? `${message} - ${this.formatError(originalError)}`
      : message;

    // Log the error
    switch (logLevel) {
      case "debug":
        log(`[${type}.${code}] (DEBUG) ${finalMessage}`);
        break;
      case "warn":
        log(`[${type}.${code}] (WARN) ${finalMessage}`);
        break;
      case "info":
        log(`[${type}.${code}] (INFO) ${finalMessage}`);
        break;
      case "error":
      default:
        log(`[${type}.${code}] (ERROR) ${finalMessage}`);
        if (originalError && originalError instanceof Error) {
          log(originalError.stack || "No stack trace available");
        }
        break;
    }

    const error = createError(type, code, finalMessage, originalError);
    this.handleError(error);
    return error;
  }

  /**
   * Recupera gli ultimi N errori
   * @param count - Numero di errori da recuperare
   * @returns Lista degli errori più recenti
   */
  static getRecentErrors(count: number = 10): ShogunError[] {
    return this.errors.slice(-Math.min(count, this.errors.length));
  }

  /**
   * Aggiunge un ascoltatore per gli errori
   * @param listener - Funzione che verrà chiamata quando si verifica un errore
   */
  static addListener(listener: (error: ShogunError) => void): void {
    this.listeners.push(listener);
  }

  /**
   * Rimuove un ascoltatore per gli errori
   * @param listener - Funzione da rimuovere
   */
  static removeListener(listener: (error: ShogunError) => void): void {
    const index = this.listeners.indexOf(listener);
    if (index !== -1) {
      this.listeners.splice(index, 1);
    }
  }

  /**
   * Notifica tutti gli ascoltatori di un errore
   * @param error - Errore da notificare
   */
  private static notifyListeners(error: ShogunError): void {
    for (const listener of this.listeners) {
      try {
        listener(error);
      } catch (listenerError) {
        logError(`Error in error listener: ${listenerError}`);
      }
    }
  }

  /**
   * Funzione helper per formattare messaggi di errore dagli errori nativi
   * @param error - Errore da formattare
   * @returns Messaggio di errore formattato
   */
  static formatError(error: Error | unknown): string {
    if (!error) {
      return "Unknown error";
    }

    if (error instanceof Error) {
      return `${error.name}: ${error.message}`;
    }

    if (typeof error === "string") {
      return error;
    }

    if (typeof error === "object") {
      try {
        return JSON.stringify(error);
      } catch (e) {
        return `Object: ${Object.prototype.toString.call(error)}`;
      }
    }

    return String(error);
  }

  /**
   * Error handling with retry logic
   */
  static async withRetry<T>(
    fn: () => Promise<T>,
    errorType: ErrorType,
    errorCode: string,
    maxRetries = 3,
    retryDelay = 1000
  ): Promise<T> {
    let lastError: unknown;

    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        return await fn();
      } catch (error) {
        lastError = error;
        const delay = retryDelay * attempt;

        if (attempt < maxRetries) {
          log(
            `Retrying operation after ${delay}ms (attempt ${attempt}/${maxRetries})`
          );
          await new Promise((resolve) => setTimeout(resolve, delay));
        }
      }
    }

    // If we got here, all retries failed
    throw this.handle(
      errorType,
      errorCode,
      `Operation failed after ${maxRetries} attempts`,
      lastError
    );
  }
}

1	import { log, logError } from "./logger";	5✔
2	import { LogLevel } from "../types/common";
3
4	/**
5	* Tipi di errore che possono verificarsi nell'applicazione
6	*/
7	export enum ErrorType {	5✔
8	AUTHENTICATION = "AuthenticationError",	5✔
9	AUTHORIZATION = "AuthorizationError",	5✔
10	VALIDATION = "ValidationError",	5✔
11	NETWORK = "NetworkError",	5✔
12	DATABASE = "DatabaseError",	5✔
13	WALLET = "WalletError",	5✔
14	DID = "DIDError",	5✔
15	STORAGE = "StorageError",	5✔
16	ENCRYPTION = "EncryptionError",	5✔
17	SIGNATURE = "SignatureError",	5✔
18	ENVIRONMENT = "EnvironmentError",	5✔
19	SECURITY = "SecurityError",	5✔
20	GUN = "GunError",	5✔
21	STEALTH = "StealthError",	5✔
22	WEBAUTHN = "WebAuthnError",	5✔
23	PLUGIN = "PluginError",	5✔
24	UNKNOWN = "UnknownError",	5✔
25	CONNECTOR = "CONNECTOR",	5✔
26	GENERAL = "GENERAL",	5✔
27	}
28
29	/**
30	* Interfaccia standard per errori di Shogun
31	*/
32	export interface ShogunError {
33	type: ErrorType;
34	code: string;
35	message: string;
36	originalError?: Error \| unknown;
37	timestamp: number;
38	}
39
40	/**
41	* Wrapper per standardizzare gli errori
42	* @param type - Tipo di errore
43	* @param code - Codice errore
44	* @param message - Messaggio errore
45	* @param originalError - Errore originale
46	* @returns Un oggetto di errore strutturato
47	*/
48	export function createError(	5✔
49	type: ErrorType,
50	code: string,
51	message: string,
52	originalError?: Error \| unknown
53	): ShogunError {
54	return {	×
55	type,
56	code,
57	message,
58	originalError,
59	timestamp: Date.now(),
60	};
61	}
62
63	/**
64	* Opzioni di configurazione per il gestore di errori
65	*/
66	export interface ErrorOptions {
67	message?: string;
68	throwError?: boolean;
69	logError?: boolean;
70	callback?: ErrorCallback;
71	}
72
73	/**
74	* Tipo della funzione di callback per errori
75	*/
76	export type ErrorCallback = (error: any) => any;
77
78	/**
79	* Risultato standardizzato per gestione errori
80	*/
81	export interface ErrorResult {
82	success: boolean;
83	message: string;
84	error?: any;
85	}
86
87	/**
88	* Funzione di utilità per gestire gli errori in modo consistente
89	* @param error - L'errore da gestire
90	* @param options - Opzioni di configurazione
91	* @returns Risultato dell'operazione o il risultato della callback
92	*/
93	export function handleError(	5✔
94	error: any,
95	options: ErrorOptions = {}	×
96	): ErrorResult \| any {
97	// Impostazioni di default
98	const {
99	message = error instanceof Error ? error.message : String(error),	8✔
100	throwError = false,	×
101	logError = true,	3✔
102	callback,
103	} = options;	6✔
104
105	// Log dell'errore se richiesto
106	if (logError) {	6✔
107	console.error(`[ERROR] ${message}`, error);	4✔
108	}
109
110	// Se è stata fornita una callback, la eseguiamo e restituiamo il suo risultato
111	if (typeof callback === "function") {	6✔
112	return callback(error);	1✔
113	}
114
115	// Se è richiesto di lanciare l'errore, lo lanciamo
116	if (throwError) {	5✔
117	if (error instanceof Error) {	1!
118	throw error;	1✔
119	} else {
NEW 120	throw new Error(message);	×
121	}
122	}
123
124	// Altrimenti restituiamo un oggetto di risultato standard
125	return {	4✔
126	success: false,
127	message,
128	error,
129	};
130	}
131
132	/**
133	* Gestore centralizzato per errori
134	*/
135	export class ErrorHandler {	5✔
136	private static errors: ShogunError[] = [];	5✔
137	private static maxErrors: number = 100;	5✔
138	private static listeners: Array<(error: ShogunError) => void> = [];	5✔
139
140	/**
141	* Gestisce un errore registrandolo e notificando gli ascoltatori
142	* @param error - L'errore da gestire
143	*/
144	static handleError(error: ShogunError): void {
145	// Log l'errore
146	logError(`[${error.type}] ${error.code}: ${error.message}`);	×
147
148	// Conserva l'errore nella memoria
149	this.errors.push(error);	×
150
151	// Mantiene solo gli ultimi maxErrors
152	if (this.errors.length > this.maxErrors) {	×
153	this.errors = this.errors.slice(-this.maxErrors);	×
154	}
155
156	// Notifica gli ascoltatori
157	this.notifyListeners(error);	×
158	}
159
160	/**
161	* Gestisce un errore grezzo convertendolo in ShogunError
162	* @param type - Tipo errore
163	* @param code - Codice errore
164	* @param message - Messaggio errore
165	* @param originalError - Errore originale
166	*/
167	static handle(
168	type: ErrorType,
169	code: string,
170	message: string,
171	originalError?: Error \| unknown,
172	logLevel: LogLevel = "error"	×
173	): ShogunError {
174	// Create a formatted error message
175	const finalMessage = originalError	×
176	? `${message} - ${this.formatError(originalError)}`
177	: message;
178
179	// Log the error
180	switch (logLevel) {	×
181	case "debug":
182	log(`[${type}.${code}] (DEBUG) ${finalMessage}`);	×
183	break;	×
184	case "warn":
185	log(`[${type}.${code}] (WARN) ${finalMessage}`);	×
186	break;	×
187	case "info":
188	log(`[${type}.${code}] (INFO) ${finalMessage}`);	×
189	break;	×
190	case "error":
191	default:
192	log(`[${type}.${code}] (ERROR) ${finalMessage}`);	×
193	if (originalError && originalError instanceof Error) {	×
194	log(originalError.stack \|\| "No stack trace available");	×
195	}
196	break;	×
197	}
198
199	const error = createError(type, code, finalMessage, originalError);	×
200	this.handleError(error);	×
201	return error;	×
202	}
203
204	/**
205	* Recupera gli ultimi N errori
206	* @param count - Numero di errori da recuperare
207	* @returns Lista degli errori più recenti
208	*/
209	static getRecentErrors(count: number = 10): ShogunError[] {	×
210	return this.errors.slice(-Math.min(count, this.errors.length));	×
211	}
212
213	/**
214	* Aggiunge un ascoltatore per gli errori
215	* @param listener - Funzione che verrà chiamata quando si verifica un errore
216	*/
217	static addListener(listener: (error: ShogunError) => void): void {
218	this.listeners.push(listener);	×
219	}
220
221	/**
222	* Rimuove un ascoltatore per gli errori
223	* @param listener - Funzione da rimuovere
224	*/
225	static removeListener(listener: (error: ShogunError) => void): void {
226	const index = this.listeners.indexOf(listener);	×
227	if (index !== -1) {	×
228	this.listeners.splice(index, 1);	×
229	}
230	}
231
232	/**
233	* Notifica tutti gli ascoltatori di un errore
234	* @param error - Errore da notificare
235	*/
236	private static notifyListeners(error: ShogunError): void {
237	for (const listener of this.listeners) {	×
238	try {	×
239	listener(error);	×
240	} catch (listenerError) {
241	logError(`Error in error listener: ${listenerError}`);	×
242	}
243	}
244	}
245
246	/**
247	* Funzione helper per formattare messaggi di errore dagli errori nativi
248	* @param error - Errore da formattare
249	* @returns Messaggio di errore formattato
250	*/
251	static formatError(error: Error \| unknown): string {
252	if (!error) {	×
253	return "Unknown error";	×
254	}
255
256	if (error instanceof Error) {	×
257	return `${error.name}: ${error.message}`;	×
258	}
259
260	if (typeof error === "string") {	×
261	return error;	×
262	}
263
264	if (typeof error === "object") {	×
265	try {	×
266	return JSON.stringify(error);	×
267	} catch (e) {
268	return `Object: ${Object.prototype.toString.call(error)}`;	×
269	}
270	}
271
272	return String(error);	×
273	}
274
275	/**
276	* Error handling with retry logic
277	*/
278	static async withRetry<T>(
279	fn: () => Promise<T>,
280	errorType: ErrorType,
281	errorCode: string,
282	maxRetries = 3,	×
283	retryDelay = 1000	×
284	): Promise<T> {
285	let lastError: unknown;
286
287	for (let attempt = 1; attempt <= maxRetries; attempt++) {	×
288	try {	×
289	return await fn();	×
290	} catch (error) {
291	lastError = error;	×
292	const delay = retryDelay * attempt;	×
293
294	if (attempt < maxRetries) {	×
295	log(	×
296	`Retrying operation after ${delay}ms (attempt ${attempt}/${maxRetries})`
297	);
298	await new Promise((resolve) => setTimeout(resolve, delay));	×
299	}
300	}
301	}
302
303	// If we got here, all retries failed
304	throw this.handle(	×
305	errorType,
306	errorCode,
307	`Operation failed after ${maxRetries} attempts`,
308	lastError
309	);
310	}
311	}

scobru / shogun-core / 14528264067

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous