syntropylog/dist/serialization/pipeline/SerializationStep.js

An instance manager with observability for Node.js applications

export class SerializationStep {
    name = 'serialization';
    serializers = [];
    constructor(serializers = []) {
        this.serializers = serializers;
    }
    addSerializer(serializer) {
        // Insertar en orden de prioridad (mayor prioridad primero)
        const insertIndex = this.serializers.findIndex((s) => s.priority < serializer.priority);
        if (insertIndex === -1) {
            this.serializers.push(serializer);
        }
        else {
            this.serializers.splice(insertIndex, 0, serializer);
        }
    }
    async execute(data, context) {
        const startTime = Date.now();
        // 1. Encontrar serializador apropiado
        const serializer = this.findSerializer(data);
        if (!serializer) {
            // Si no hay serializador, terminar inmediatamente
            const error = new Error(`No se encontró serializador para los datos proporcionados`);
            error.serializer = 'none';
            throw error;
        }
        // 2. Ejecutar serialización con timeout ultra-bajo
        const serializationPromise = serializer.serialize(data, context.serializationContext);
        const timeoutPromise = new Promise((_, reject) => {
            setTimeout(() => {
                const error = new Error(`Serialización lenta: >10ms`);
                error.serializer = serializer.name;
                reject(error);
            }, 10);
        });
        try {
            const result = await Promise.race([serializationPromise, timeoutPromise]);
            // 3. Verificar que la serialización fue rápida
            const duration = Date.now() - startTime;
            if (duration > 10) {
                const error = new Error(`Serialización demasiado lenta: ${duration}ms (máximo 10ms)`);
                error.serializer = serializer.name;
                throw error;
            }
            // 4. Devolver datos serializados con metadata
            return {
                ...result.data,
                serializationDuration: duration,
                serializer: serializer.name,
                serializationComplexity: result.complexity || result.metadata?.complexity || null,
            };
        }
        catch (error) {
            // Asegurar que el error tenga el nombre del serializador
            if (error instanceof Error && !error.serializer) {
                error.serializer = serializer.name;
            }
            throw error;
        }
    }
    findSerializer(data) {
        // Los serializers ya están ordenados por prioridad (mayor primero)
        // debido al método addSerializer, así que solo necesitamos encontrar el primero
        // que pueda serializar los datos
        for (const serializer of this.serializers) {
            if (serializer.canSerialize(data)) {
                return serializer;
            }
        }
        return null;
    }
    getRegisteredSerializers() {
        return this.serializers.map((s) => s.name);
    }
}
//# sourceMappingURL=SerializationStep.js.map