@hestjs/logger/dist/serializers.js

HestJS Logger - A powerful logging solution based on Pino

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.querySerializer = exports.userSerializer = exports.responseSerializer = exports.requestSerializer = exports.errorSerializer = void 0;
exports.getDefaultSerializers = getDefaultSerializers;
exports.createSerializer = createSerializer;
const stdSerializers = __importStar(require("pino-std-serializers"));
/**
 * 错误序列化器 - 扩展标准错误序列化器
 */
const errorSerializer = (err) => {
    const serialized = stdSerializers.err(err);
    return {
        ...serialized,
        // 添加额外的错误信息
        name: err.name,
        message: err.message,
        stack: err.stack,
        // 如果是 HTTP 错误，添加状态码
        ...(err.status && { status: err.status }),
        ...(err.statusCode && { statusCode: err.statusCode }),
    };
};
exports.errorSerializer = errorSerializer;
/**
 * 请求序列化器
 */
const requestSerializer = (req) => {
    if (!req)
        return req;
    return {
        id: req.id,
        method: req.method,
        url: req.url,
        path: req.path,
        parameters: req.parameters,
        query: req.query,
        headers: {
            // 只记录重要的头部信息，避免敏感信息泄露
            "content-type": req.headers?.["content-type"],
            "user-agent": req.headers?.["user-agent"],
            accept: req.headers?.["accept"],
            "accept-encoding": req.headers?.["accept-encoding"],
            "accept-language": req.headers?.["accept-language"],
        },
        remoteAddress: req.socket?.remoteAddress,
        remotePort: req.socket?.remotePort,
    };
};
exports.requestSerializer = requestSerializer;
/**
 * 响应序列化器
 */
const responseSerializer = (res) => {
    if (!res)
        return res;
    return {
        statusCode: res.statusCode,
        headers: {
            "content-type": res.getHeader?.("content-type"),
            "content-length": res.getHeader?.("content-length"),
        },
    };
};
exports.responseSerializer = responseSerializer;
/**
 * 用户序列化器 - 避免敏感信息泄露
 */
const userSerializer = (user) => {
    if (!user)
        return user;
    const { password, token, secret, ...safeUser } = user;
    return safeUser;
};
exports.userSerializer = userSerializer;
/**
 * 数据库查询序列化器
 */
const querySerializer = (query) => {
    if (!query)
        return query;
    return {
        sql: query.sql,
        duration: query.duration,
        rowCount: query.rowCount,
        // 不记录参数值，避免敏感数据泄露
        hasParameters: Array.isArray(query.parameters) && query.parameters.length > 0,
    };
};
exports.querySerializer = querySerializer;
/**
 * 获取默认序列化器
 */
function getDefaultSerializers() {
    return {
        // 使用 pino 标准的序列化器
        req: stdSerializers.req,
        res: stdSerializers.res,
        // 不使用任何错误序列化器，让pino使用默认处理
        // 自定义序列化器
        user: exports.userSerializer,
        query: exports.querySerializer,
    };
}
/**
 * 创建自定义序列化器
 */
function createSerializer(fn) {
    return (value) => {
        try {
            return fn(value);
        }
        catch (error) {
            // 如果序列化失败，返回安全的字符串表示
            return `[Serialization Error: ${error instanceof Error ? error.message : "Unknown"}]`;
        }
    };
}
//# sourceMappingURL=serializers.js.map