@qrvey/health-checker/dist/cjs/services/healthCheck.service.js

 

"use strict";
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HealthCheckService = void 0;
exports.buildDetails = buildDetails;
const registry_1 = require("../registry");
const systemStatusGateway_service_1 = require("./gateways/systemStatusGateway.service");
const checkersMap_1 = require("../utils/checkersMap");
const constants_1 = require("../utils/constants");
const logger_1 = __importDefault(require("../utils/logger"));
const withTimeout_1 = require("../utils/withTimeout");
class HealthCheckService {
    static async check(dependencies, params = {}) {
        const selectedDependencies = resolveDependencies(dependencies);
        if (!params.force) {
            const result = await tryFetchRemoteHealthReport(selectedDependencies, params);
            if (result)
                return result;
        }
        const results = await runDependencyChecks(selectedDependencies, params);
        return buildDetails(selectedDependencies, results);
    }
}
exports.HealthCheckService = HealthCheckService;
function resolveDependencies(dependencies, skip) {
    const all = dependencies !== null && dependencies !== void 0 ? dependencies : (0, registry_1.getRegisteredHealthChecks)();
    return skip ? all.filter((dep) => !skip.includes(dep)) : all;
}
async function runDependencyChecks(dependencies, params = {}) {
    return Promise.allSettled(dependencies.map(async (dep) => {
        var _a;
        const checker = checkersMap_1.checkersMap[dep];
        if (!checker) {
            const msg = `[HealthCheckService] No checker found for dependency "${dep}"`;
            logger_1.default.error(msg);
            return Promise.reject(new Error(msg));
        }
        const depParams = params;
        const dependencyParam = (_a = depParams[dep]) !== null && _a !== void 0 ? _a : {};
        const mergedParam = Object.assign(Object.assign({}, dependencyParam), { hostName: params.hostName });
        try {
            return await (0, withTimeout_1.withTimeoutAndTiming)(dep, checker.check(mergedParam));
        }
        catch (err) {
            logger_1.default.error(`[${dep}] HealthChecker threw an error`, err);
            return Promise.reject(err);
        }
    }));
}
async function tryFetchRemoteHealthReport(dependencies, params) {
    try {
        const { skip = [], force = false, hostName } = params, otherParams = __rest(params, ["skip", "force", "hostName"]);
        const body = {
            dependencies,
            service: hostName !== null && hostName !== void 0 ? hostName : (process.env.HOSTNAME || 'unknown'),
            skip,
            force,
            params: otherParams,
        };
        const result = await (0, withTimeout_1.withTimeout)(constants_1.SYSTEM_STATUS_GATEWAY_CONTEXT, systemStatusGateway_service_1.SystemStatusGateway.getHealthReport(body));
        return result;
    }
    catch (err) {
        const message = err instanceof Error
            ? err.message
            : 'Unknown error during remote check';
        logger_1.default.warn(`[HealthCheckService] Remote health check fallback triggered: ${message}`);
        return null;
    }
}
function buildDetails(dependencies, results) {
    var _a, _b, _c;
    const details = {};
    let hasFailure = false;
    for (let i = 0; i < dependencies.length; i++) {
        const dep = dependencies[i];
        const result = results[i];
        if (result.status === 'fulfilled') {
            const isVoid = result.value.status === constants_1.VOID;
            details[dep] = {
                status: isVoid ? constants_1.VOID : constants_1.OK,
                durationMs: result.value.durationMs,
                metadata: (_a = result.value.metadata) !== null && _a !== void 0 ? _a : {},
            };
        }
        else {
            details[dep] = {
                status: constants_1.FAILED,
                durationMs: (_c = (_b = result.reason) === null || _b === void 0 ? void 0 : _b.durationMs) !== null && _c !== void 0 ? _c : 0,
            };
            hasFailure = true;
        }
    }
    return {
        status: hasFailure ? constants_1.FAILED : constants_1.OK,
        details,
    };
}
//# sourceMappingURL=healthCheck.service.js.map