checklist-mcp-server
Version:
An MCP server for hierarchical checklist management with HTTP streamable transport support.
227 lines (226 loc) • 7.27 kB
JavaScript
;
/**
* Work Information Validation Utilities
* Validation functions for work info data structures and inputs
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateWorkSummarize = validateWorkSummarize;
exports.validateWorkDescription = validateWorkDescription;
exports.validateSessionId = validateSessionId;
exports.validateWorkId = validateWorkId;
exports.validateSaveWorkInfoInput = validateSaveWorkInfoInput;
exports.validateGetWorkByIdInput = validateGetWorkByIdInput;
exports.validateWorkInfo = validateWorkInfo;
exports.createTimestamp = createTimestamp;
exports.isValidTimestamp = isValidTimestamp;
const workIdGenerator_1 = require("./workIdGenerator");
/**
* Validates work summary text
* @param work_summarize The work summary to validate
* @returns Validation result
*/
function validateWorkSummarize(work_summarize) {
const errors = [];
if (!work_summarize) {
errors.push('work_summarize is required');
}
else if (typeof work_summarize !== 'string') {
errors.push('work_summarize must be a string');
}
else if (work_summarize.trim().length === 0) {
errors.push('work_summarize cannot be empty');
}
else if (work_summarize.length > 5000) {
errors.push('work_summarize cannot exceed 5000 characters');
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* Validates work description text
* @param work_description The work description to validate
* @returns Validation result
*/
function validateWorkDescription(work_description) {
const errors = [];
if (!work_description) {
errors.push('work_description is required');
}
else if (typeof work_description !== 'string') {
errors.push('work_description must be a string');
}
else if (work_description.trim().length === 0) {
errors.push('work_description cannot be empty');
}
else if (work_description.length > 200) {
errors.push('work_description cannot exceed 200 characters');
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* Validates session ID format
* @param sessionId The session ID to validate
* @returns Validation result
*/
function validateSessionId(sessionId) {
const errors = [];
if (typeof sessionId !== 'string') {
errors.push('sessionId must be a string');
}
else if (sessionId.length < 1 || sessionId.length > 100) {
errors.push('sessionId must be between 1 and 100 characters long');
}
else {
// Check for valid characters (alphanumeric, hyphens, underscores)
const validSessionIdRegex = /^[a-zA-Z0-9_-]+$/;
if (!validSessionIdRegex.test(sessionId)) {
errors.push('sessionId can only contain alphanumeric characters, hyphens, and underscores');
}
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* Validates work ID format
* @param workId The work ID to validate
* @returns Validation result
*/
function validateWorkId(workId) {
const errors = [];
if (!workId) {
errors.push('workId is required');
}
else if (typeof workId !== 'string') {
errors.push('workId must be a string');
}
else if (!workIdGenerator_1.WorkIdGenerator.isValidWorkId(workId)) {
errors.push('workId must be an 8-digit numeric string (10000000-99999999)');
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* Validates SaveWorkInfoInput data
* @param input The input data to validate
* @returns Validation result
*/
function validateSaveWorkInfoInput(input) {
const errors = [];
if (!input || typeof input !== 'object') {
errors.push('Input must be a valid object');
return { isValid: false, errors };
}
// Validate work_summarize
const summarizeValidation = validateWorkSummarize(input.work_summarize);
errors.push(...summarizeValidation.errors);
// Validate work_description
const descriptionValidation = validateWorkDescription(input.work_description);
errors.push(...descriptionValidation.errors);
// Validate sessionId if provided
if (input.sessionId !== undefined && input.sessionId !== null) {
const sessionIdValidation = validateSessionId(input.sessionId);
errors.push(...sessionIdValidation.errors);
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* Validates GetWorkByIdInput data
* @param input The input data to validate
* @returns Validation result
*/
function validateGetWorkByIdInput(input) {
const errors = [];
if (!input || typeof input !== 'object') {
errors.push('Input must be a valid object');
return { isValid: false, errors };
}
// Validate workId
const workIdValidation = validateWorkId(input.workId);
errors.push(...workIdValidation.errors);
return {
isValid: errors.length === 0,
errors
};
}
/**
* Validates complete WorkInfo object
* @param workInfo The work info object to validate
* @returns Validation result
*/
function validateWorkInfo(workInfo) {
const errors = [];
if (!workInfo || typeof workInfo !== 'object') {
errors.push('WorkInfo must be a valid object');
return { isValid: false, errors };
}
// Validate workId
const workIdValidation = validateWorkId(workInfo.workId);
errors.push(...workIdValidation.errors);
// Validate work_timestamp
if (!workInfo.work_timestamp) {
errors.push('work_timestamp is required');
}
else if (typeof workInfo.work_timestamp !== 'string') {
errors.push('work_timestamp must be a string');
}
else {
// Validate ISO format
try {
const date = new Date(workInfo.work_timestamp);
if (isNaN(date.getTime())) {
errors.push('work_timestamp must be a valid ISO date string');
}
}
catch (e) {
errors.push('work_timestamp must be a valid ISO date string');
}
}
// Validate work_description
const descriptionValidation = validateWorkDescription(workInfo.work_description);
errors.push(...descriptionValidation.errors);
// Validate work_summarize
const summarizeValidation = validateWorkSummarize(workInfo.work_summarize);
errors.push(...summarizeValidation.errors);
// Validate sessionId if provided
if (workInfo.sessionId !== undefined && workInfo.sessionId !== null) {
const sessionIdValidation = validateSessionId(workInfo.sessionId);
errors.push(...sessionIdValidation.errors);
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* Creates a timestamp string in ISO format
* @returns ISO formatted timestamp string
*/
function createTimestamp() {
return new Date().toISOString();
}
/**
* Validates timestamp format
* @param timestamp The timestamp to validate
* @returns true if valid ISO format, false otherwise
*/
function isValidTimestamp(timestamp) {
try {
const date = new Date(timestamp);
return !isNaN(date.getTime()) && date.toISOString() === timestamp;
}
catch (e) {
return false;
}
}