@syntropylog/adapters/dist/types/serializers/prisma/PrismaSerializer.js

External adapters for SyntropyLog framework

export class PrismaSerializer {
    constructor() {
        this.name = 'prisma';
        this.priority = 75;
    }
    canSerialize(data) {
        return (this.isPrismaQuery(data) ||
            this.isPrismaError(data) ||
            this.isPrismaClient(data));
    }
    getComplexity(data) {
        if (this.isPrismaQuery(data)) {
            return this.assessQueryComplexity(data);
        }
        if (this.isPrismaError(data)) {
            return 'low';
        }
        if (this.isPrismaClient(data)) {
            return 'low';
        }
        return 'low';
    }
    async serialize(data, context) {
        const startTime = Date.now();
        try {
            let result;
            if (this.isPrismaQuery(data)) {
                result = this.serializeQuery(data);
            }
            else if (this.isPrismaError(data)) {
                result = this.serializeError(data);
            }
            else if (this.isPrismaClient(data)) {
                result = this.serializeClient(data);
            }
            else {
                throw new Error('Tipo de dato Prisma no reconocido');
            }
            const duration = Date.now() - startTime;
            // ✅ Verificar que la serialización respeta el timeout del contexto
            const timeout = context.timeout || 50;
            if (duration > timeout) {
                throw new Error(`Serialización lenta: ${duration}ms (máximo ${timeout}ms)`);
            }
            return {
                success: true,
                data: result,
                metadata: {
                    serializer: this.name,
                    complexity: this.getComplexity(data),
                    duration,
                    timestamp: new Date().toISOString()
                }
            };
        }
        catch (error) {
            const duration = Date.now() - startTime;
            return {
                success: false,
                error: error instanceof Error ? error.message : 'Error desconocido en serialización Prisma',
                metadata: {
                    serializer: this.name,
                    complexity: this.getComplexity(data),
                    duration,
                    timestamp: new Date().toISOString()
                }
            };
        }
    }
    isPrismaQuery(data) {
        return (data &&
            typeof data === 'object' &&
            typeof data.model === 'string' &&
            typeof data.action === 'string');
    }
    isPrismaError(data) {
        return (data &&
            typeof data === 'object' &&
            typeof data.code === 'string' &&
            typeof data.message === 'string');
    }
    isPrismaClient(data) {
        return (data &&
            typeof data === 'object' &&
            typeof data.$connect === 'function' &&
            typeof data.$disconnect === 'function' &&
            typeof data.$queryRaw === 'function');
    }
    assessQueryComplexity(query) {
        let complexity = 0;
        // Basado en la acción
        if (query.action === 'findMany')
            complexity += 1;
        else if (query.action === 'findFirst')
            complexity += 1;
        else if (query.action === 'findUnique')
            complexity += 1;
        else if (query.action === 'create')
            complexity += 2;
        else if (query.action === 'update')
            complexity += 2;
        else if (query.action === 'updateMany')
            complexity += 3;
        else if (query.action === 'delete')
            complexity += 2;
        else if (query.action === 'deleteMany')
            complexity += 3;
        else if (query.action === 'upsert')
            complexity += 3;
        else if (query.action === 'aggregate')
            complexity += 4;
        else if (query.action === 'groupBy')
            complexity += 4;
        else if (query.action === 'count')
            complexity += 1;
        // Basado en argumentos complejos
        if (query.args) {
            if (query.args.include)
                complexity += 1;
            if (query.args.select)
                complexity += 1;
            if (query.args.where && typeof query.args.where === 'object') {
                const whereKeys = Object.keys(query.args.where);
                complexity += Math.min(whereKeys.length, 2);
            }
            if (query.args.orderBy)
                complexity += 1;
            if (query.args.take)
                complexity += 1;
            if (query.args.skip)
                complexity += 1;
            if (query.args.distinct)
                complexity += 1;
        }
        if (complexity >= 7)
            return 'high';
        if (complexity >= 4)
            return 'medium';
        return 'low';
    }
    serializeQuery(query) {
        return {
            type: 'PrismaQuery',
            model: query.model,
            action: query.action,
            args: query.args, // Datos originales, sin sanitizar
            duration: query.duration,
            timestamp: query.timestamp,
            complexity: this.assessQueryComplexity(query)
        };
    }
    serializeError(error) {
        return {
            type: 'PrismaError',
            code: error.code,
            message: error.message,
            meta: error.meta, // Datos originales, sin sanitizar
            clientVersion: error.clientVersion,
            stack: error.stack
        };
    }
    serializeClient(client) {
        return {
            type: 'PrismaClient',
            hasConnect: typeof client.$connect === 'function',
            hasDisconnect: typeof client.$disconnect === 'function',
            hasQueryRaw: typeof client.$queryRaw === 'function',
            hasExecuteRaw: typeof client.$executeRaw === 'function',
            hasTransaction: typeof client.$transaction === 'function',
            hasUse: typeof client.$use === 'function',
            hasOn: typeof client.$on === 'function'
        };
    }
}
//# sourceMappingURL=PrismaSerializer.js.map