@analog-tools/logger/lib/error-serialization/error-serializer.d.ts

Logging utility for AnalogJS applications

import { StructuredError, ErrorSerializationOptions } from './error.types';
/**
 * Utility class for safely serializing errors and objects for logging
 *
 * Provides robust error serialization with support for:
 * - Standard Error objects with stack traces
 * - Circular reference detection and handling
 * - Maximum depth limits to prevent infinite recursion
 * - Non-enumerable property inclusion options
 * - Safe stringification of any value type
 *
 * @example
 * ```typescript
 * // Serialize a standard Error
 * const error = new Error('Something went wrong');
 * const serialized = ErrorSerializer.serialize(error);
 *
 * // Serialize with custom options
 * const serialized = ErrorSerializer.serialize(error, {
 *   includeStack: false,
 *   maxDepth: 5,
 *   includeNonEnumerable: true
 * });
 *
 * // Serialize any object
 * const obj = { nested: { data: 'value' } };
 * const serialized = ErrorSerializer.serialize(obj);
 * ```
 */
export declare class ErrorSerializer {
    private static readonly DEFAULT_MAX_DEPTH;
    private static readonly CIRCULAR_REF_PLACEHOLDER;
    private static readonly MAX_DEPTH_PLACEHOLDER;
    private static readonly UNABLE_TO_SERIALIZE;
    private static readonly serializationCache;
    private static readonly MAX_CACHE_SIZE;
    /**
     * Generate a cache key for memoization (includes serialization options)
     * @private
     */
    private static getCacheKey;
    /**
     * Add to cache with size limit enforcement
     * @private
     */
    private static addToCache;
    /**
     * Safely serialize any value (Error objects, plain objects, primitives) for logging
     *
     * @param error - The value to serialize (Error, object, string, etc.)
     * @param options - Configuration options for serialization behavior
     * @returns Serialized representation - StructuredError for Error objects, string for others
     *
     * @example
     * ```typescript
     * // Serialize an Error object
     * const error = new Error('Failed to connect');
     * const result = ErrorSerializer.serialize(error);
     * // Returns: { message: 'Failed to connect', name: 'Error', stack: '...' }
     *
     * // Serialize a plain object
     * const obj = { userId: '123', action: 'login' };
     * const result = ErrorSerializer.serialize(obj);
     * // Returns: '{\n  "userId": "123",\n  "action": "login"\n}'
     *
     * // Serialize with options
     * const result = ErrorSerializer.serialize(error, { includeStack: false });
     * ```
     */
    static serialize(error: unknown, options?: ErrorSerializationOptions): StructuredError | string;
    /**
     * Serialize a standard Error object
     * @private
     */
    private static serializeError;
    /**
     * Safely stringify any object with circular reference detection
     * @private
     */
    private static safeStringify;
}