@rhofkens/mcp-quotes-server/dist/utils/parameter-validator.js

A Model Context Protocol (MCP) server that provides quotes based on user requests

import { logger } from "./logger.js";
export function validateQuoteParameters(rawParams) {
    logger.debug("Starting parameter validation", { rawParams });
    const errors = [];
    let person;
    let topic;
    let numberOfQuotes;
    const personValidation = validatePersonParameter(rawParams.person);
    if (personValidation.success) {
        person = personValidation.value;
    }
    else {
        errors.push(...personValidation.errors);
    }
    const topicValidation = validateTopicParameter(rawParams.topic);
    if (topicValidation.success) {
        topic = topicValidation.value;
    }
    else {
        errors.push(...topicValidation.errors);
    }
    const numberOfQuotesValidation = validateNumberOfQuotesParameter(rawParams.numberOfQuotes);
    if (numberOfQuotesValidation.success) {
        numberOfQuotes = numberOfQuotesValidation.value;
    }
    else {
        errors.push(...numberOfQuotesValidation.errors);
    }
    if (errors.length > 0) {
        logger.debug("Parameter validation failed", { errors, rawParams });
        return {
            success: false,
            errors,
        };
    }
    const validatedParams = {
        person: person,
        topic,
        numberOfQuotes: numberOfQuotes,
    };
    logger.debug("Parameter validation succeeded", { validatedParams });
    return {
        success: true,
        data: validatedParams,
    };
}
function validatePersonParameter(person) {
    if (person === null || person === undefined) {
        return {
            success: false,
            errors: ["Person parameter is required"],
        };
    }
    if (typeof person !== "string") {
        return {
            success: false,
            errors: ["Person parameter must be a string"],
        };
    }
    const trimmedPerson = person.trim();
    if (trimmedPerson.length === 0) {
        return {
            success: false,
            errors: ["Person parameter cannot be empty"],
        };
    }
    return {
        success: true,
        value: trimmedPerson,
        errors: [],
    };
}
function validateTopicParameter(topic) {
    if (topic === null || topic === undefined) {
        return {
            success: true,
            value: undefined,
            errors: [],
        };
    }
    if (typeof topic !== "string") {
        return {
            success: false,
            errors: ["Topic parameter must be a string when provided"],
        };
    }
    const trimmedTopic = topic.trim();
    if (trimmedTopic.length === 0) {
        return {
            success: true,
            value: undefined,
            errors: [],
        };
    }
    return {
        success: true,
        value: trimmedTopic,
        errors: [],
    };
}
function validateNumberOfQuotesParameter(numberOfQuotes) {
    if (numberOfQuotes === null || numberOfQuotes === undefined) {
        return {
            success: false,
            errors: ["Number of quotes parameter is required"],
        };
    }
    if (typeof numberOfQuotes !== "number") {
        return {
            success: false,
            errors: ["Number of quotes parameter must be a number"],
        };
    }
    if (!Number.isInteger(numberOfQuotes)) {
        return {
            success: false,
            errors: ["Number of quotes parameter must be an integer"],
        };
    }
    if (numberOfQuotes < 1 || numberOfQuotes > 10) {
        return {
            success: false,
            errors: ["Number of quotes parameter must be between 1 and 10"],
        };
    }
    return {
        success: true,
        value: numberOfQuotes,
        errors: [],
    };
}
//# sourceMappingURL=parameter-validator.js.map