n8n-MCP

"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.EnhancedConfigValidator = void 0; const config_validator_1 = require("./config-validator"); const node_specific_validators_1 = require("./node-specific-validators"); const fixed_collection_validator_1 = require("../utils/fixed-collection-validator"); const operation_similarity_service_1 = require("./operation-similarity-service"); const resource_similarity_service_1 = require("./resource-similarity-service"); const node_type_normalizer_1 = require("../utils/node-type-normalizer"); const type_structure_service_1 = require("./type-structure-service"); class EnhancedConfigValidator extends config_validator_1.ConfigValidator { static initializeSimilarityServices(repository) { this.nodeRepository = repository; this.operationSimilarityService = new operation_similarity_service_1.OperationSimilarityService(repository); this.resourceSimilarityService = new resource_similarity_service_1.ResourceSimilarityService(repository); } static validateWithMode(nodeType, config, properties, mode = 'operation', profile = 'ai-friendly') { if (typeof nodeType !== 'string') { throw new Error(`Invalid nodeType: expected string, got ${typeof nodeType}`); } if (!config || typeof config !== 'object') { throw new Error(`Invalid config: expected object, got ${typeof config}`); } if (!Array.isArray(properties)) { throw new Error(`Invalid properties: expected array, got ${typeof properties}`); } const operationContext = this.extractOperationContext(config); const userProvidedKeys = new Set(Object.keys(config)); const { properties: filteredProperties, configWithDefaults } = this.filterPropertiesByMode(properties, config, mode, operationContext); const baseResult = super.validate(nodeType, configWithDefaults, filteredProperties, userProvidedKeys); const enhancedResult = { ...baseResult, mode, profile, operation: operationContext, examples: [], nextSteps: [], errors: baseResult.errors || [], warnings: baseResult.warnings || [], suggestions: baseResult.suggestions || [] }; this.applyProfileFilters(enhancedResult, profile); this.addOperationSpecificEnhancements(nodeType, config, filteredProperties, enhancedResult); enhancedResult.errors = this.deduplicateErrors(enhancedResult.errors); enhancedResult.nextSteps = this.generateNextSteps(enhancedResult); enhancedResult.valid = enhancedResult.errors.length === 0; return enhancedResult; } static extractOperationContext(config) { return { resource: config.resource, operation: config.operation, action: config.action, mode: config.mode }; } static filterPropertiesByMode(properties, config, mode, operation) { const configWithDefaults = this.applyNodeDefaults(properties, config); let filteredProperties; switch (mode) { case 'minimal': filteredProperties = properties.filter(prop => prop.required && this.isPropertyVisible(prop, configWithDefaults)); break; case 'operation': filteredProperties = properties.filter(prop => this.isPropertyRelevantToOperation(prop, configWithDefaults, operation)); break; case 'full': default: filteredProperties = properties; break; } return { properties: filteredProperties, configWithDefaults }; } static applyNodeDefaults(properties, config) { const result = { ...config }; for (const prop of properties) { if (prop.name && prop.default !== undefined && result[prop.name] === undefined) { result[prop.name] = prop.default; } } return result; } static isPropertyRelevantToOperation(prop, config, operation) { if (!this.isPropertyVisible(prop, config)) { return false; } if (!operation.resource && !operation.operation && !operation.action) { return true; } if (prop.displayOptions?.show) { const show = prop.displayOptions.show; if (operation.resource && show.resource) { const expectedResources = Array.isArray(show.resource) ? show.resource : [show.resource]; if (!expectedResources.includes(operation.resource)) { return false; } } if (operation.operation && show.operation) { const expectedOps = Array.isArray(show.operation) ? show.operation : [show.operation]; if (!expectedOps.includes(operation.operation)) { return false; } } if (operation.action && show.action) { const expectedActions = Array.isArray(show.action) ? show.action : [show.action]; if (!expectedActions.includes(operation.action)) { return false; } } } return true; } static addOperationSpecificEnhancements(nodeType, config, properties, result) { if (typeof nodeType !== 'string') { result.errors.push({ type: 'invalid_type', property: 'nodeType', message: `Invalid nodeType: expected string, got ${typeof nodeType}`, fix: 'Provide a valid node type string (e.g., "nodes-base.webhook")' }); return; } this.validateResourceAndOperation(nodeType, config, result); this.validateSpecialTypeStructures(config, properties, result); this.validateFixedCollectionStructures(nodeType, config, result); const context = { config, errors: result.errors, warnings: result.warnings, suggestions: result.suggestions, autofix: result.autofix || {} }; const normalizedNodeType = nodeType.replace('n8n-nodes-base.', 'nodes-base.'); switch (normalizedNodeType) { case 'nodes-base.slack': node_specific_validators_1.NodeSpecificValidators.validateSlack(context); this.enhanceSlackValidation(config, result); break; case 'nodes-base.googleSheets': node_specific_validators_1.NodeSpecificValidators.validateGoogleSheets(context); this.enhanceGoogleSheetsValidation(config, result); break; case 'nodes-base.httpRequest': this.enhanceHttpRequestValidation(config, result); break; case 'nodes-base.code': node_specific_validators_1.NodeSpecificValidators.validateCode(context); break; case 'nodes-base.openAi': node_specific_validators_1.NodeSpecificValidators.validateOpenAI(context); break; case 'nodes-base.mongoDb': node_specific_validators_1.NodeSpecificValidators.validateMongoDB(context); break; case 'nodes-base.webhook': node_specific_validators_1.NodeSpecificValidators.validateWebhook(context); break; case 'nodes-base.postgres': node_specific_validators_1.NodeSpecificValidators.validatePostgres(context); break; case 'nodes-base.mysql': node_specific_validators_1.NodeSpecificValidators.validateMySQL(context); break; case 'nodes-langchain.agent': node_specific_validators_1.NodeSpecificValidators.validateAIAgent(context); break; case 'nodes-base.set': node_specific_validators_1.NodeSpecificValidators.validateSet(context); break; case 'nodes-base.switch': this.validateSwitchNodeStructure(config, result); break; case 'nodes-base.if': this.validateIfNodeStructure(config, result); break; case 'nodes-base.filter': this.validateFilterNodeStructure(config, result); break; } if (Object.keys(context.autofix).length > 0) { result.autofix = context.autofix; } } static enhanceSlackValidation(config, result) { const { resource, operation } = result.operation || {}; if (resource === 'message' && operation === 'send') { if (!config.channel && !config.channelId) { const channelError = result.errors.find(e => e.property === 'channel' || e.property === 'channelId'); if (channelError) { channelError.message = 'To send a Slack message, specify either a channel name (e.g., "#general") or channel ID'; channelError.fix = 'Add channel: "#general" or use a channel ID like "C1234567890"'; } } } } static enhanceGoogleSheetsValidation(config, result) { const { operation } = result.operation || {}; if (operation === 'append') { if (config.range && !config.range.includes('!')) { result.warnings.push({ type: 'inefficient', property: 'range', message: 'Range should include sheet name (e.g., "Sheet1!A:B")', suggestion: 'Format: "SheetName!A1:B10" or "SheetName!A:B" for entire columns' }); } } } static enhanceHttpRequestValidation(config, result) { const url = String(config.url || ''); const options = config.options || {}; if (!result.suggestions.some(s => typeof s === 'string' && s.includes('alwaysOutputData'))) { result.suggestions.push('Consider adding alwaysOutputData: true at node level (not in parameters) for better error handling. ' + 'This ensures the node produces output even when HTTP requests fail, allowing downstream error handling.'); } const lowerUrl = url.toLowerCase(); const isApiEndpoint = /^https?:\/\/api\./i.test(url) || /\/api[\/\?]|\/api$/i.test(url) || /\/rest[\/\?]|\/rest$/i.test(url) || lowerUrl.includes('supabase.co') || lowerUrl.includes('firebase') || lowerUrl.includes('googleapis.com') || /\.com\/v\d+/i.test(url); if (isApiEndpoint && !options.response?.response?.responseFormat) { result.suggestions.push('API endpoints should explicitly set options.response.response.responseFormat to "json" or "text" ' + 'to prevent confusion about response parsing. Example: ' + '{ "options": { "response": { "response": { "responseFormat": "json" } } } }'); } if (url && url.startsWith('=')) { const expressionContent = url.slice(1); const lowerExpression = expressionContent.toLowerCase(); if (expressionContent.startsWith('www.') || (expressionContent.includes('{{') && !lowerExpression.includes('http'))) { result.warnings.push({ type: 'invalid_value', property: 'url', message: 'URL expression appears to be missing http:// or https:// protocol', suggestion: 'Include protocol in your expression. Example: ={{ "https://" + $json.domain + ".com" }}' }); } } } static generateNextSteps(result) { const steps = []; const requiredErrors = result.errors.filter(e => e.type === 'missing_required'); const typeErrors = result.errors.filter(e => e.type === 'invalid_type'); const valueErrors = result.errors.filter(e => e.type === 'invalid_value'); if (requiredErrors.length > 0) { steps.push(`Add required fields: ${requiredErrors.map(e => e.property).join(', ')}`); } if (typeErrors.length > 0) { steps.push(`Fix type mismatches: ${typeErrors.map(e => `${e.property} should be ${e.fix}`).join(', ')}`); } if (valueErrors.length > 0) { steps.push(`Correct invalid values: ${valueErrors.map(e => e.property).join(', ')}`); } if (result.warnings.length > 0 && result.errors.length === 0) { steps.push('Consider addressing warnings for better reliability'); } if (result.errors.length > 0) { steps.push('Fix the errors above following the provided suggestions'); } return steps; } static deduplicateErrors(errors) { const seen = new Map(); for (const error of errors) { const key = `${error.property}-${error.type}`; const existing = seen.get(key); if (!existing) { seen.set(key, error); } else { const existingLength = (existing.message?.length || 0) + (existing.fix?.length || 0); const newLength = (error.message?.length || 0) + (error.fix?.length || 0); if (newLength > existingLength) { seen.set(key, error); } } } return Array.from(seen.values()); } static shouldFilterCredentialWarning(warning) { return warning.type === 'security' && warning.message !== undefined && warning.message.includes('Hardcoded nodeCredentialType'); } static applyProfileFilters(result, profile) { switch (profile) { case 'minimal': result.errors = result.errors.filter(e => e.type === 'missing_required'); result.warnings = result.warnings.filter(w => { if (this.shouldFilterCredentialWarning(w)) { return false; } return w.type === 'security' || w.type === 'deprecated'; }); result.suggestions = []; break; case 'runtime': result.errors = result.errors.filter(e => e.type === 'missing_required' || e.type === 'invalid_value' || (e.type === 'invalid_type' && e.message.includes('undefined'))); result.warnings = result.warnings.filter(w => { if (this.shouldFilterCredentialWarning(w)) { return false; } if (w.type === 'security' || w.type === 'deprecated') return true; if (w.type === 'inefficient' && w.message && w.message.includes('not visible')) { return false; } return false; }); result.suggestions = []; break; case 'strict': if (result.warnings.length === 0 && result.errors.length === 0) { result.suggestions.push('Consider adding error handling with onError property and timeout configuration'); result.suggestions.push('Add authentication if connecting to external services'); } this.enforceErrorHandlingForProfile(result, profile); break; case 'ai-friendly': default: result.warnings = result.warnings.filter(w => { if (this.shouldFilterCredentialWarning(w)) { return false; } if (w.type === 'security' || w.type === 'deprecated') return true; if (w.type === 'missing_common') return true; if (w.type === 'best_practice') return true; if (w.type === 'inefficient' && w.message && w.message.includes('not visible')) { return false; } if (w.type === 'inefficient' && w.property?.startsWith('_')) { return false; } return true; }); this.addErrorHandlingSuggestions(result); break; } } static enforceErrorHandlingForProfile(result, profile) { if (profile !== 'strict') return; const nodeType = result.operation?.resource || ''; const errorProneTypes = ['httpRequest', 'webhook', 'database', 'api', 'slack', 'email', 'openai']; if (errorProneTypes.some(type => nodeType.toLowerCase().includes(type))) { result.warnings.push({ type: 'best_practice', property: 'errorHandling', message: 'External service nodes should have error handling configured', suggestion: 'Add onError: "continueRegularOutput" or "stopWorkflow" with retryOnFail: true for resilience' }); } } static addErrorHandlingSuggestions(result) { const hasNetworkErrors = result.errors.some(e => e.message.toLowerCase().includes('url') || e.message.toLowerCase().includes('endpoint') || e.message.toLowerCase().includes('api')); if (hasNetworkErrors) { result.suggestions.push('For API calls, consider adding onError: "continueRegularOutput" with retryOnFail: true and maxTries: 3'); } const isWebhook = result.operation?.resource === 'webhook' || result.errors.some(e => e.message.toLowerCase().includes('webhook')); if (isWebhook) { result.suggestions.push('Webhooks should use onError: "continueRegularOutput" to ensure responses are always sent'); } } static validateFixedCollectionStructures(nodeType, config, result) { const validationResult = fixed_collection_validator_1.FixedCollectionValidator.validate(nodeType, config); if (!validationResult.isValid) { for (const error of validationResult.errors) { result.errors.push({ type: 'invalid_value', property: error.pattern.split('.')[0], message: error.message, fix: error.fix }); } if (validationResult.autofix) { if (typeof validationResult.autofix === 'object' && !Array.isArray(validationResult.autofix)) { result.autofix = { ...result.autofix, ...validationResult.autofix }; } else { const firstError = validationResult.errors[0]; if (firstError) { const rootProperty = firstError.pattern.split('.')[0]; result.autofix = { ...result.autofix, [rootProperty]: validationResult.autofix }; } } } } } static validateSwitchNodeStructure(config, result) { if (!config.rules) return; const hasFixedCollectionError = result.errors.some(e => e.property === 'rules' && e.message.includes('propertyValues[itemName] is not iterable')); if (hasFixedCollectionError) return; if (config.rules.values && Array.isArray(config.rules.values)) { config.rules.values.forEach((rule, index) => { if (!rule.conditions) { result.warnings.push({ type: 'missing_common', property: 'rules', message: `Switch rule ${index + 1} is missing "conditions" property`, suggestion: 'Each rule in the values array should have a "conditions" property' }); } if (!rule.outputKey && rule.renameOutput !== false) { result.warnings.push({ type: 'missing_common', property: 'rules', message: `Switch rule ${index + 1} is missing "outputKey" property`, suggestion: 'Add "outputKey" to specify which output to use when this rule matches' }); } }); } } static validateIfNodeStructure(config, result) { if (!config.conditions) return; const hasFixedCollectionError = result.errors.some(e => e.property === 'conditions' && e.message.includes('propertyValues[itemName] is not iterable')); if (hasFixedCollectionError) return; } static validateFilterNodeStructure(config, result) { if (!config.conditions) return; const hasFixedCollectionError = result.errors.some(e => e.property === 'conditions' && e.message.includes('propertyValues[itemName] is not iterable')); if (hasFixedCollectionError) return; } static validateResourceAndOperation(nodeType, config, result) { if (!this.operationSimilarityService || !this.resourceSimilarityService || !this.nodeRepository) { return; } const normalizedNodeType = node_type_normalizer_1.NodeTypeNormalizer.normalizeToFullForm(nodeType); const configWithDefaults = { ...config }; if (configWithDefaults.operation === undefined && configWithDefaults.resource !== undefined) { const defaultOperation = this.nodeRepository.getDefaultOperationForResource(normalizedNodeType, configWithDefaults.resource); if (defaultOperation !== undefined) { configWithDefaults.operation = defaultOperation; } } if (config.resource !== undefined) { result.errors = result.errors.filter(e => e.property !== 'resource'); const validResources = this.nodeRepository.getNodeResources(normalizedNodeType); const resourceIsValid = validResources.some(r => { const resourceValue = typeof r === 'string' ? r : r.value; return resourceValue === config.resource; }); if (!resourceIsValid && config.resource !== '') { let suggestions = []; try { suggestions = this.resourceSimilarityService.findSimilarResources(normalizedNodeType, config.resource, 3); } catch (error) { console.error('Resource similarity service error:', error); } let errorMessage = `Invalid resource "${config.resource}" for node ${nodeType}.`; let fix = ''; if (suggestions.length > 0) { const topSuggestion = suggestions[0]; errorMessage += ` Did you mean "${topSuggestion.value}"?`; if (topSuggestion.confidence >= 0.8) { fix = `Change resource to "${topSuggestion.value}". ${topSuggestion.reason}`; } else { fix = `Valid resources: ${validResources.slice(0, 5).map(r => { const val = typeof r === 'string' ? r : r.value; return `"${val}"`; }).join(', ')}${validResources.length > 5 ? '...' : ''}`; } } else { fix = `Valid resources: ${validResources.slice(0, 5).map(r => { const val = typeof r === 'string' ? r : r.value; return `"${val}"`; }).join(', ')}${validResources.length > 5 ? '...' : ''}`; } const error = { type: 'invalid_value', property: 'resource', message: errorMessage, fix }; if (suggestions.length > 0 && suggestions[0].confidence >= 0.5) { error.suggestion = `Did you mean "${suggestions[0].value}"? ${suggestions[0].reason}`; } result.errors.push(error); if (suggestions.length > 0) { for (const suggestion of suggestions) { result.suggestions.push(`Resource "${config.resource}" not found. Did you mean "${suggestion.value}"? ${suggestion.reason}`); } } } } if (config.operation !== undefined || configWithDefaults.operation !== undefined) { result.errors = result.errors.filter(e => e.property !== 'operation'); const operationToValidate = configWithDefaults.operation || config.operation; const validOperations = this.nodeRepository.getNodeOperations(normalizedNodeType, config.resource); const operationIsValid = validOperations.some(op => { const opValue = op.operation || op.value || op; return opValue === operationToValidate; }); if (!operationIsValid && config.operation !== undefined && config.operation !== '') { let suggestions = []; try { suggestions = this.operationSimilarityService.findSimilarOperations(normalizedNodeType, config.operation, config.resource, 3); } catch (error) { console.error('Operation similarity service error:', error); } let errorMessage = `Invalid operation "${config.operation}" for node ${nodeType}`; if (config.resource) { errorMessage += ` with resource "${config.resource}"`; } errorMessage += '.'; let fix = ''; if (suggestions.length > 0) { const topSuggestion = suggestions[0]; if (topSuggestion.confidence >= 0.8) { errorMessage += ` Did you mean "${topSuggestion.value}"?`; fix = `Change operation to "${topSuggestion.value}". ${topSuggestion.reason}`; } else { errorMessage += ` Similar operations: ${suggestions.map(s => `"${s.value}"`).join(', ')}`; fix = `Valid operations${config.resource ? ` for resource "${config.resource}"` : ''}: ${validOperations.slice(0, 5).map(op => { const val = op.operation || op.value || op; return `"${val}"`; }).join(', ')}${validOperations.length > 5 ? '...' : ''}`; } } else { fix = `Valid operations${config.resource ? ` for resource "${config.resource}"` : ''}: ${validOperations.slice(0, 5).map(op => { const val = op.operation || op.value || op; return `"${val}"`; }).join(', ')}${validOperations.length > 5 ? '...' : ''}`; } const error = { type: 'invalid_value', property: 'operation', message: errorMessage, fix }; if (suggestions.length > 0 && suggestions[0].confidence >= 0.5) { error.suggestion = `Did you mean "${suggestions[0].value}"? ${suggestions[0].reason}`; } result.errors.push(error); if (suggestions.length > 0) { for (const suggestion of suggestions) { result.suggestions.push(`Operation "${config.operation}" not found. Did you mean "${suggestion.value}"? ${suggestion.reason}`); } } } } } static validateSpecialTypeStructures(config, properties, result) { for (const [key, value] of Object.entries(config)) { if (value === undefined || value === null) continue; const propDef = properties.find(p => p.name === key); if (!propDef) continue; let structureType = null; if (propDef.type === 'filter') { structureType = 'filter'; } else if (propDef.type === 'resourceMapper') { structureType = 'resourceMapper'; } else if (propDef.type === 'assignmentCollection') { structureType = 'assignmentCollection'; } else if (propDef.type === 'resourceLocator') { structureType = 'resourceLocator'; } if (!structureType) continue; const structure = type_structure_service_1.TypeStructureService.getStructure(structureType); if (!structure) { console.warn(`No structure definition found for type: ${structureType}`); continue; } const validationResult = type_structure_service_1.TypeStructureService.validateTypeCompatibility(value, structureType); if (!validationResult.valid) { for (const error of validationResult.errors) { result.errors.push({ type: 'invalid_configuration', property: key, message: error, fix: `Ensure ${key} follows the expected structure for ${structureType} type. Example: ${JSON.stringify(structure.example)}` }); } } for (const warning of validationResult.warnings) { result.warnings.push({ type: 'best_practice', property: key, message: warning }); } if (typeof value === 'object' && value !== null) { this.validateComplexTypeStructure(key, value, structureType, structure, result); } if (structureType === 'filter' && value.conditions) { this.validateFilterOperations(value.conditions, key, result); } } } static validateComplexTypeStructure(propertyName, value, type, structure, result) { switch (type) { case 'filter': if (!value.combinator) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.combinator`, message: 'Filter must have a combinator field', fix: 'Add combinator: "and" or combinator: "or" to the filter configuration' }); } else if (value.combinator !== 'and' && value.combinator !== 'or') { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.combinator`, message: `Invalid combinator value: ${value.combinator}. Must be "and" or "or"`, fix: 'Set combinator to either "and" or "or"' }); } if (!value.conditions) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.conditions`, message: 'Filter must have a conditions field', fix: 'Add conditions array to the filter configuration' }); } else if (!Array.isArray(value.conditions)) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.conditions`, message: 'Filter conditions must be an array', fix: 'Ensure conditions is an array of condition objects' }); } break; case 'resourceLocator': if (!value.mode) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.mode`, message: 'ResourceLocator must have a mode field', fix: 'Add mode: "id", mode: "url", or mode: "list" to the resourceLocator configuration' }); } else if (!['id', 'url', 'list', 'name'].includes(value.mode)) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.mode`, message: `Invalid mode value: ${value.mode}. Must be "id", "url", "list", or "name"`, fix: 'Set mode to one of: "id", "url", "list", "name"' }); } if (!value.hasOwnProperty('value')) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.value`, message: 'ResourceLocator must have a value field', fix: 'Add value field to the resourceLocator configuration' }); } break; case 'assignmentCollection': if (!value.assignments) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.assignments`, message: 'AssignmentCollection must have an assignments field', fix: 'Add assignments array to the assignmentCollection configuration' }); } else if (!Array.isArray(value.assignments)) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.assignments`, message: 'AssignmentCollection assignments must be an array', fix: 'Ensure assignments is an array of assignment objects' }); } break; case 'resourceMapper': if (!value.mappingMode) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.mappingMode`, message: 'ResourceMapper must have a mappingMode field', fix: 'Add mappingMode: "defineBelow" or mappingMode: "autoMapInputData"' }); } else if (!['defineBelow', 'autoMapInputData'].includes(value.mappingMode)) { result.errors.push({ type: 'invalid_configuration', property: `${propertyName}.mappingMode`, message: `Invalid mappingMode: ${value.mappingMode}. Must be "defineBelow" or "autoMapInputData"`, fix: 'Set mappingMode to either "defineBelow" or "autoMapInputData"' }); } break; } } static validateFilterOperations(conditions, propertyName, result) { if (!Array.isArray(conditions)) return; const VALID_OPERATIONS_BY_TYPE = { string: [ 'empty', 'notEmpty', 'equals', 'notEquals', 'contains', 'notContains', 'startsWith', 'notStartsWith', 'endsWith', 'notEndsWith', 'regex', 'notRegex', 'exists', 'notExists', 'isNotEmpty' ], number: [ 'empty', 'notEmpty', 'equals', 'notEquals', 'gt', 'lt', 'gte', 'lte', 'exists', 'notExists', 'isNotEmpty' ], dateTime: [ 'empty', 'notEmpty', 'equals', 'notEquals', 'after', 'before', 'afterOrEquals', 'beforeOrEquals', 'exists', 'notExists', 'isNotEmpty' ], boolean: [ 'empty', 'notEmpty', 'true', 'false', 'equals', 'notEquals', 'exists', 'notExists', 'isNotEmpty' ], array: [ 'contains', 'notContains', 'lengthEquals', 'lengthNotEquals', 'lengthGt', 'lengthLt', 'lengthGte', 'lengthLte', 'empty', 'notEmpty', 'exists', 'notExists', 'isNotEmpty' ], object: [ 'empty', 'notEmpty', 'exists', 'notExists', 'isNotEmpty' ], any: ['exists', 'notExists', 'isNotEmpty'] }; for (let i = 0; i < conditions.length; i++) { const condition = conditions[i]; if (!condition.operator || typeof condition.operator !== 'object') continue; const { type, operation } = condition.operator; if (!type || !operation) continue; const validOperations = VALID_OPERATIONS_BY_TYPE[type]; if (!validOperations) { result.warnings.push({ type: 'best_practice', property: `${propertyName}.conditions[${i}].operator.type`, message: `Unknown operator type: ${type}` }); continue; } if (!validOperations.includes(operation)) { result.errors.push({ type: 'invalid_value', property: `${propertyName}.conditions[${i}].operator.operation`, message: `Operation '${operation}' is not valid for type '${type}'`, fix: `Use one of the valid operations for ${type}: ${validOperations.join(', ')}` }); } } } } exports.EnhancedConfigValidator = EnhancedConfigValidator; EnhancedConfigValidator.operationSimilarityService = null; EnhancedConfigValidator.resourceSimilarityService = null; EnhancedConfigValidator.nodeRepository = null; //# sourceMappingURL=enhanced-config-validator.js.map