From 93cd0cd7ab75b91f35df8a8ebb6fee1bbd31fb8e Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 24 Sep 2025 09:09:20 +0000 Subject: [PATCH] feat: Add schema validation and nightly job Co-authored-by: max.mrtnv --- .../src/jobs/nightly-validation.job.ts | 473 +++++++++++ .../schema-validation/README.md | 465 +++++++++++ .../schema-validation/client-validator.ts | 483 +++++++++++ .../schema-validation/custom-validators.ts | 381 +++++++++ .../schema-validation/debug-inspector.ts | 616 ++++++++++++++ .../schema-validation/error-formatter.ts | 463 +++++++++++ .../schema-validation/index.ts | 89 +- .../schema-validation/master.schema.json | 388 +++++++++ .../schema-validation/schema-versioning.ts | 434 ++++++++++ .../schema-validation/security-validator.ts | 497 +++++++++++ .../schema-validation/store-integration.ts | 423 ++++++++++ .../schema-validation/validation-engine.ts | 771 ++++++++++++++++++ .../schema-validation/validation.service.ts | 322 ++++++++ 13 files changed, 5804 insertions(+), 1 deletion(-) create mode 100644 packages/application/src/jobs/nightly-validation.job.ts create mode 100644 packages/domain/src/schema-management/schema-validation/README.md create mode 100644 packages/domain/src/schema-management/schema-validation/client-validator.ts create mode 100644 packages/domain/src/schema-management/schema-validation/custom-validators.ts create mode 100644 packages/domain/src/schema-management/schema-validation/debug-inspector.ts create mode 100644 packages/domain/src/schema-management/schema-validation/error-formatter.ts create mode 100644 packages/domain/src/schema-management/schema-validation/master.schema.json create mode 100644 packages/domain/src/schema-management/schema-validation/schema-versioning.ts create mode 100644 packages/domain/src/schema-management/schema-validation/security-validator.ts create mode 100644 packages/domain/src/schema-management/schema-validation/store-integration.ts create mode 100644 packages/domain/src/schema-management/schema-validation/validation-engine.ts create mode 100644 packages/domain/src/schema-management/schema-validation/validation.service.ts diff --git a/packages/application/src/jobs/nightly-validation.job.ts b/packages/application/src/jobs/nightly-validation.job.ts new file mode 100644 index 0000000..1b70490 --- /dev/null +++ b/packages/application/src/jobs/nightly-validation.job.ts @@ -0,0 +1,473 @@ +import { ValidationService, BatchValidationRequest } from '../../domain/src/schema-management/schema-validation/validation.service.js' +import { SchemaValidationResult } from '../../domain/src/schema-management/schema-validation/value-objects/validation-result.vo.js' +import { ErrorFormatter } from '../../domain/src/schema-management/schema-validation/error-formatter.js' +import { CustomValidatorsRegistry } from '../../domain/src/schema-management/schema-validation/custom-validators.js' + +export interface NightlyValidationConfig { + batchSize: number + maxConcurrentJobs: number + failThreshold: number // Percentage (0-100) + reportEmailRecipients: string[] + slackWebhookUrl?: string + retryAttempts: number + retryDelay: number // milliseconds +} + +export interface ValidationJob { + id: string + configId: string + configVersion: string + data: unknown + priority: 'high' | 'normal' | 'low' + retryCount: number + createdAt: Date + startedAt?: Date + completedAt?: Date + status: 'pending' | 'running' | 'completed' | 'failed' | 'retry' + result?: SchemaValidationResult + error?: string +} + +export interface NightlyValidationReport { + jobId: string + startTime: Date + endTime: Date + duration: number + totalConfigs: number + validatedConfigs: number + validConfigs: number + invalidConfigs: number + errorRate: number + failThreshold: number + exceededThreshold: boolean + summary: { + totalErrors: number + totalWarnings: number + totalInfo: number + criticalErrors: number + averageValidationTime: number + } + configResults: Array<{ + configId: string + configVersion: string + isValid: boolean + errorCount: number + warningCount: number + infoCount: number + validationTime: number + errors: Array<{ + path: string + message: string + code: string + }> + }> + recommendations: string[] +} + +export class NightlyValidationJob { + private validationService: ValidationService + private config: NightlyValidationConfig + private errorFormatter: ErrorFormatter + private customValidators: CustomValidatorsRegistry + private currentJobId: string + private jobQueue: ValidationJob[] = [] + private activeJobs: Map = new Map() + private completedJobs: ValidationJob[] = [] + private isRunning: boolean = false + private eventListeners: Array<(event: ValidationJobEvent) => void> = [] + + constructor( + validationService: ValidationService, + config: NightlyValidationConfig, + ) { + this.validationService = validationService + this.config = config + this.errorFormatter = ErrorFormatter.create({ + includeCode: true, + includeSeverity: true, + includeDetails: true, + sortBy: 'severity', + }) + this.customValidators = new CustomValidatorsRegistry() + this.currentJobId = this.generateJobId() + } + + public async start(configs: Array<{ id: string; version: string; data: unknown }>): Promise { + if (this.isRunning) { + throw new Error('Nightly validation job is already running') + } + + this.isRunning = true + this.jobQueue = [] + this.activeJobs.clear() + this.completedJobs = [] + this.currentJobId = this.generateJobId() + + // Create jobs for all configs + for (const config of configs) { + this.jobQueue.push({ + id: this.generateJobId(), + configId: config.id, + configVersion: config.version, + data: config.data, + priority: 'normal', + retryCount: 0, + createdAt: new Date(), + status: 'pending', + }) + } + + // Sort jobs by priority + this.jobQueue.sort((a, b) => { + const priorityOrder = { high: 0, normal: 1, low: 2 } + return priorityOrder[a.priority] - priorityOrder[b.priority] + }) + + this.emitEvent({ + type: 'job_started', + jobId: this.currentJobId, + message: `Nightly validation started with ${configs.length} configurations`, + }) + + // Start processing jobs + this.processJobs() + + return this.currentJobId + } + + public async stop(): Promise { + this.isRunning = false + this.jobQueue = [] + this.activeJobs.clear() + + this.emitEvent({ + type: 'job_stopped', + jobId: this.currentJobId, + message: 'Nightly validation stopped by user', + }) + } + + public getStatus(): { + isRunning: boolean + jobId: string + queuedJobs: number + activeJobs: number + completedJobs: number + totalJobs: number + progress: number + } { + const totalJobs = this.jobQueue.length + this.activeJobs.size + this.completedJobs.length + const completedCount = this.completedJobs.length + const progress = totalJobs > 0 ? (completedCount / totalJobs) * 100 : 0 + + return { + isRunning: this.isRunning, + jobId: this.currentJobId, + queuedJobs: this.jobQueue.length, + activeJobs: this.activeJobs.size, + completedJobs: completedCount, + totalJobs, + progress: Math.round(progress * 100) / 100, + } + } + + public getCurrentReport(): NightlyValidationReport | null { + if (this.completedJobs.length === 0) { + return null + } + + const startTime = this.completedJobs[0]?.createdAt || new Date() + const endTime = this.completedJobs[this.completedJobs.length - 1]?.completedAt || new Date() + const duration = endTime.getTime() - startTime.getTime() + + const totalConfigs = this.completedJobs.length + const validConfigs = this.completedJobs.filter((job) => job.result?.isValid).length + const invalidConfigs = totalConfigs - validConfigs + const errorRate = totalConfigs > 0 ? (invalidConfigs / totalConfigs) * 100 : 0 + + const totalErrors = this.completedJobs.reduce((sum, job) => sum + (job.result?.errorCount || 0), 0) + const totalWarnings = this.completedJobs.reduce((sum, job) => sum + (job.result?.warningCount || 0), 0) + const totalInfo = this.completedJobs.reduce((sum, job) => sum + (job.result?.infoCount || 0), 0) + const criticalErrors = this.completedJobs.reduce((sum, job) => sum + (job.result?.hasCriticalErrors ? 1 : 0), 0) + const totalDuration = this.completedJobs.reduce((sum, job) => sum + (job.result?.duration || 0), 0) + const averageValidationTime = this.completedJobs.length > 0 ? totalDuration / this.completedJobs.length : 0 + + const configResults = this.completedJobs.map((job) => ({ + configId: job.configId, + configVersion: job.configVersion, + isValid: job.result?.isValid || false, + errorCount: job.result?.errorCount || 0, + warningCount: job.result?.warningCount || 0, + infoCount: job.result?.infoCount || 0, + validationTime: job.result?.duration || 0, + errors: this.errorFormatter + .formatReport(job.result || SchemaValidationResult.success()) + .errors.slice(0, 10) // Limit to first 10 errors + .map((error) => ({ + path: error.path, + message: error.message, + code: error.code || '', + })), + })) + + const exceededThreshold = errorRate > this.config.failThreshold + const recommendations = this.generateRecommendations(errorRate, exceededThreshold, configResults) + + return { + jobId: this.currentJobId, + startTime, + endTime, + duration, + totalConfigs, + validatedConfigs: totalConfigs, + validConfigs, + invalidConfigs, + errorRate, + failThreshold: this.config.failThreshold, + exceededThreshold, + summary: { + totalErrors, + totalWarnings, + totalInfo, + criticalErrors, + averageValidationTime, + }, + configResults, + recommendations, + } + } + + public onEvent(listener: (event: ValidationJobEvent) => void): void { + this.eventListeners.push(listener) + } + + public removeEventListener(listener: (event: ValidationJobEvent) => void): void { + const index = this.eventListeners.indexOf(listener) + if (index > -1) { + this.eventListeners.splice(index, 1) + } + } + + private async processJobs(): Promise { + while (this.isRunning && this.jobQueue.length > 0) { + const activeJobCount = this.activeJobs.size + + if (activeJobCount >= this.config.maxConcurrentJobs) { + // Wait for some jobs to complete + await this.waitForJobCompletion() + continue + } + + // Start new jobs + const jobsToStart = Math.min( + this.config.maxConcurrentJobs - activeJobCount, + this.jobQueue.length, + ) + + for (let i = 0; i < jobsToStart; i++) { + const job = this.jobQueue.shift()! + this.startJob(job) + } + } + + // Wait for all active jobs to complete + while (this.activeJobs.size > 0) { + await this.waitForJobCompletion() + } + + // Generate final report + const report = this.getCurrentReport() + if (report) { + this.emitEvent({ + type: 'job_completed', + jobId: this.currentJobId, + message: `Nightly validation completed. Valid: ${report.validConfigs}/${report.totalConfigs}, Error rate: ${report.errorRate.toFixed(2)}%`, + }) + + // Send notifications if threshold exceeded + if (report.exceededThreshold) { + await this.sendThresholdExceededNotification(report) + } + } + + this.isRunning = false + } + + private async startJob(job: ValidationJob): Promise { + job.status = 'running' + job.startedAt = new Date() + this.activeJobs.set(job.id, job) + + this.emitEvent({ + type: 'job_progress', + jobId: this.currentJobId, + configId: job.configId, + message: `Started validation for config ${job.configId}`, + }) + + try { + const result = await this.validationService.validate({ + data: job.data, + options: { + strict: true, + includeWarnings: true, + includeInfo: true, + customValidators: ['security', 'componentType', 'crossField'], + }, + }) + + job.status = 'completed' + job.completedAt = new Date() + job.result = result + + this.emitEvent({ + type: 'job_progress', + jobId: this.currentJobId, + configId: job.configId, + message: `Completed validation for config ${job.configId}. Valid: ${result.isValid}`, + }) + } catch (error) { + job.status = 'failed' + job.completedAt = new Date() + job.error = error instanceof Error ? error.message : 'Unknown error' + + this.emitEvent({ + type: 'job_error', + jobId: this.currentJobId, + configId: job.configId, + message: `Failed validation for config ${job.configId}: ${job.error}`, + }) + } + + this.activeJobs.delete(job.id) + this.completedJobs.push(job) + } + + private async waitForJobCompletion(): Promise { + return new Promise((resolve) => { + const checkCompletion = () => { + if (this.activeJobs.size === 0 || !this.isRunning) { + resolve() + } else { + setTimeout(checkCompletion, 100) + } + } + checkCompletion() + }) + } + + private generateRecommendations( + errorRate: number, + exceededThreshold: boolean, + configResults: NightlyValidationReport['configResults'], + ): string[] { + const recommendations: string[] = [] + + if (exceededThreshold) { + recommendations.push('Error rate exceeded threshold. Immediate action required.') + } + + if (errorRate > 50) { + recommendations.push('Very high error rate detected. Consider reviewing all configurations.') + } else if (errorRate > 25) { + recommendations.push('High error rate detected. Review configurations with most errors.') + } else if (errorRate > 10) { + recommendations.push('Moderate error rate detected. Monitor trends.') + } + + // Find most common error patterns + const errorCounts: Record = {} + for (const result of configResults) { + for (const error of result.errors) { + errorCounts[error.code] = (errorCounts[error.code] || 0) + 1 + } + } + + const topErrors = Object.entries(errorCounts) + .sort(([, a], [, b]) => b - a) + .slice(0, 3) + + if (topErrors.length > 0) { + recommendations.push(`Most common error: ${topErrors[0][0]} (${topErrors[0][1]} occurrences)`) + } + + // Find configurations with most errors + const configsWithErrors = configResults + .filter((r) => r.errorCount > 0) + .sort((a, b) => b.errorCount - a.errorCount) + .slice(0, 5) + + if (configsWithErrors.length > 0) { + recommendations.push(`Configurations with most errors: ${configsWithErrors.map((c) => c.configId).join(', ')}`) + } + + return recommendations + } + + private async sendThresholdExceededNotification(report: NightlyValidationReport): Promise { + const message = ` +🚨 Nightly Validation Alert +Error rate exceeded threshold: ${report.errorRate.toFixed(2)}% (threshold: ${report.failThreshold}%) + +Summary: +- Total configs: ${report.totalConfigs} +- Valid: ${report.validConfigs} +- Invalid: ${report.invalidConfigs} +- Critical errors: ${report.summary.criticalErrors} + +Top error codes: +${Object.entries( + report.configResults + .flatMap((r) => r.errors) + .reduce((counts: Record, error) => { + counts[error.code] = (counts[error.code] || 0) + 1 + return counts + }, {}), +) + .sort(([, a], [, b]) => b - a) + .slice(0, 5) + .map(([code, count]) => `- ${code}: ${count}`) + .join('\n')} + +${report.recommendations.map((rec) => `• ${rec}`).join('\n')} + `.trim() + + this.emitEvent({ + type: 'threshold_exceeded', + jobId: this.currentJobId, + message, + }) + + // Here you would integrate with email service and Slack webhook + // For now, we'll just emit the event + } + + private generateJobId(): string { + return `nightly_validation_${Date.now()}_${Math.random().toString(36).substr(2, 9)}` + } + + private emitEvent(event: ValidationJobEvent): void { + for (const listener of this.eventListeners) { + try { + listener(event) + } catch (error) { + console.error('Error in validation job event listener:', error) + } + } + } + + public static create( + validationService: ValidationService, + config: NightlyValidationConfig, + ): NightlyValidationJob { + return new NightlyValidationJob(validationService, config) + } +} + +export interface ValidationJobEvent { + type: 'job_started' | 'job_progress' | 'job_completed' | 'job_stopped' | 'job_error' | 'threshold_exceeded' + jobId: string + configId?: string + message: string + data?: unknown +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/README.md b/packages/domain/src/schema-management/schema-validation/README.md new file mode 100644 index 0000000..d8f3724 --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/README.md @@ -0,0 +1,465 @@ +# Backend-Driven UI Schema Validation System + +A comprehensive validation system for backend-driven UI configurations, providing schema validation, security checks, business logic enforcement, and integration with the Store API. + +## Features + +- ✅ **Master JSON Schema** with comprehensive component definitions +- ✅ **Backend Validation Engine** with JSON Schema support and custom validators +- ✅ **Client-side Validation** for runtime safety +- ✅ **Structured Error Reporting** with path-based error tracking +- ✅ **Store API Integration** for scenario data validation +- ✅ **Nightly Validation Job** for batch re-validation +- ✅ **Debug Inspector** for development and troubleshooting +- ✅ **Schema Versioning** with migration support +- ✅ **Security Validation** with XSS, SQL injection, and URL sanitization +- ✅ **Custom Validators** for business logic and security constraints + +## Quick Start + +### Basic Validation + +```typescript +import { ValidationService } from './schema-validation' + +const validationService = ValidationService.create() + +const config = { + version: '1.0.0', + components: [ + { + type: 'Button', + props: { text: 'Click me' }, + }, + ], + scenarioData: { + user: { name: 'John', age: 30 }, + }, +} + +const result = await validationService.validate({ data: config }) + +if (result.isValid) { + console.log('Configuration is valid!') +} else { + console.log('Validation errors:', result.errors) +} +``` + +### With Custom Validators + +```typescript +import { ValidationService } from './schema-validation' +import { SecurityValidator } from './schema-validation' + +const validationService = ValidationService.create() + +// Add security validation +validationService.addCustomValidator('security', SecurityValidator.createStrict()) + +const result = await validationService.validate({ + data: config, + options: { + customValidators: ['security'], + }, +}) +``` + +### Store API Integration + +```typescript +import { ValidationService, StoreValidationAdapter } from './schema-validation' + +const validationService = ValidationService.create() +const storeAdapter = StoreValidationAdapter.create(validationService, { + mode: 'strict', + schema: { + 'user.name': { kind: 'string', required: true }, + 'user.age': { kind: 'number', required: true, min: 0, max: 150 }, + }, +}) + +// Validate store write +const validation = storeAdapter.validateWrite('user.name', { type: 'string', value: 'John' }) +if (!validation.isValid) { + console.log('Store validation failed:', validation.reason) +} +``` + +### Nightly Validation Job + +```typescript +import { NightlyValidationJob, ValidationService } from './schema-validation' + +const validationService = ValidationService.create() +const nightlyJob = NightlyValidationJob.create(validationService, { + batchSize: 10, + maxConcurrentJobs: 5, + failThreshold: 5, // 5% error rate + reportEmailRecipients: ['admin@example.com'], +}) + +const configs = [ + { id: 'config1', version: '1.0.0', data: config1 }, + { id: 'config2', version: '1.0.0', data: config2 }, +] + +const jobId = await nightlyJob.start(configs) +console.log('Nightly validation started:', jobId) + +// Monitor progress +const status = nightlyJob.getStatus() +console.log('Progress:', status.progress, '%') + +// Get final report +const report = nightlyJob.getCurrentReport() +if (report && report.exceededThreshold) { + console.log('Error rate exceeded threshold!') +} +``` + +## API Reference + +### ValidationService + +Main service for validating configurations. + +#### Methods + +- `validate(request: ValidationRequest)` - Validate a single configuration +- `validateSync(request: ValidationRequest)` - Synchronous validation +- `batchValidate(request: BatchValidationRequest)` - Validate multiple configurations +- `validateWithSchema(data, schema, context)` - Validate against a specific schema +- `formatErrors(result)` - Format validation results +- `generateReport(result)` - Generate JSON report +- `generateHTMLReport(result)` - Generate HTML report + +#### Options + +```typescript +interface ValidationServiceOptions { + schemaPath?: string // Path to custom schema + customValidators?: Map + strict?: boolean // Strict validation mode + maxDepth?: number // Maximum validation depth + maxErrors?: number // Maximum error count +} +``` + +### ValidationEngine + +Core validation engine supporting JSON Schema. + +```typescript +import { ValidationEngine } from './schema-validation' + +const engine = ValidationEngine.create(schema, { + customValidators: new Map(), + maxDepth: 10, + maxErrors: 100, +}) + +const result = await engine.validate(data, context) +``` + +### SecurityValidator + +Comprehensive security validation. + +```typescript +import { SecurityValidator } from './schema-validation' + +const securityValidator = SecurityValidator.createStrict() + +// Validate URLs +const urlResult = securityValidator.validateURL('https://example.com/image.jpg') + +// Validate image URLs +const imageResult = securityValidator.validateImageURL('https://cdn.example.com/image.png') + +// Sanitize input +const sanitized = securityValidator.sanitizeInput('') +``` + +### DebugInspector + +Development debugging and inspection tools. + +```typescript +import { DebugInspector } from './schema-validation' + +const inspector = DebugInspector.create(validationService, { debugMode: true }) + +// Inspect validation with debug info +const { result, debugInfo } = await inspector.inspectValidation(data) +console.log('Validation took:', debugInfo.executionTime, 'ms') +console.log('Steps:', debugInfo.steps) + +// Run test suite +const testSuite = inspector.generateTestSuiteFromSchema(schema) +const results = inspector.runTestSuite(testSuite) +console.log('Test results:', results) + +// Export debug data +const debugData = inspector.exportDebugData() +``` + +### ErrorFormatter + +Format validation results for different consumers. + +```typescript +import { ErrorFormatter } from './schema-validation' + +const formatter = ErrorFormatter.create({ + includeCode: true, + includeSeverity: true, + includeDetails: true, + sortBy: 'severity', + filterBySeverity: ['error', 'warning'], +}) + +// Format for admin UI +const adminUI = formatter.formatForAdminUI(result) + +// Format for client runtime +const client = formatter.formatForClientRuntime(result) + +// Generate HTML report +const htmlReport = formatter.generateHTMLReport(result) +``` + +## Schema Format + +The system uses a comprehensive JSON Schema for validation: + +### Basic Structure + +```json +{ + "version": "1.0.0", + "components": [ + { + "type": "Button", + "props": { + "text": "Click me", + "onClick": "action:submit" + } + } + ], + "scenarioData": { + "user": { + "name": "John", + "age": 30 + } + } +} +``` + +### Supported Component Types + +- **Button** - Interactive buttons with text and actions +- **Label** - Text labels with styling options +- **Text** - Rich text content +- **Image** - Image display with URL validation +- **List** - Lists of components +- **Banner** - Banner components with images +- **Container** - Layout containers +- **Card** - Card components +- **Form** - Form containers +- **Input** - Input fields +- **Select** - Dropdown selects +- **Modal** - Modal dialogs +- **Alert** - Alert messages +- **Progress** - Progress indicators + +### Security Considerations + +The system includes comprehensive security validation: + +- **XSS Prevention** - Blocks script injection attempts +- **SQL Injection Protection** - Detects SQL injection patterns +- **URL Validation** - Validates and sanitizes URLs +- **Protocol Whitelisting** - Only allows safe protocols +- **Domain Blacklisting** - Blocks dangerous domains +- **Component Type Validation** - Whitelists allowed component types +- **Input Sanitization** - Removes dangerous content + +## Configuration + +### Validation Modes + +- **Strict Mode** - Rejects all invalid data +- **Lenient Mode** - Attempts to coerce or use defaults + +### Custom Validators + +Register custom validators for business logic: + +```typescript +const customValidator = { + validate: async (value, context) => { + // Custom validation logic + return SchemaValidationResult.success(context) + } +} + +validationService.addCustomValidator('custom', customValidator) +``` + +### Schema Versioning + +The system supports schema versioning with migrations: + +```typescript +import { SchemaVersionManager, SchemaMigrationUtils } from './schema-validation' + +const versionManager = SchemaVersionManager.create(defaultVersionHistory) + +// Migrate data between versions +const migratedData = await versionManager.migrateData( + oldData, + { major: 1, minor: 0, patch: 0 }, + { major: 1, minor: 0, patch: 1 } +) +``` + +## Integration Examples + +### Admin Backend Integration + +```typescript +// In your admin backend API +app.post('/api/configs', async (req, res) => { + const validationService = ValidationService.create() + const result = await validationService.validate({ data: req.body }) + + if (!result.isValid) { + return res.status(400).json({ + error: 'Validation failed', + errors: result.errors, + }) + } + + // Save validated config + const config = await saveConfig(req.body) + res.json(config) +}) +``` + +### Client-side Runtime Validation + +```typescript +// In your client application +import { ClientValidator } from './schema-validation' + +const clientValidator = ClientValidator.createFromJSONSchema(masterSchema) + +const result = clientValidator.validateSync(config) + +if (!result.isValid) { + // Show validation errors to user + displayErrors(result.errors) +} else { + // Render validated config + renderConfig(config) +} +``` + +### Store API Integration + +```typescript +// Integrate with Store API +const storeAdapter = StoreValidationAdapter.create(validationService, { + mode: 'strict', + schema: { + 'cart.total': { kind: 'number', required: true, min: 0 }, + 'user.email': { kind: 'string', required: true, pattern: '.+@.+\..+' }, + }, +}) + +store.configureValidation(storeAdapter.getValidationOptions()) +``` + +## Monitoring and Reporting + +### Nightly Validation Reports + +The nightly validation job generates comprehensive reports: + +```typescript +const report = nightlyJob.getCurrentReport() + +console.log('Validation Summary:', { + totalConfigs: report.totalConfigs, + validConfigs: report.validConfigs, + errorRate: report.errorRate, + exceededThreshold: report.exceededThreshold, +}) +``` + +### Debug Inspector + +Use the debug inspector for troubleshooting: + +```typescript +const inspector = DebugInspector.create(validationService, { debugMode: true }) + +const { result, debugInfo } = await inspector.inspectValidation(config) + +console.log('Validation Steps:', debugInfo.steps) +console.log('Execution Time:', debugInfo.executionTime, 'ms') + +// Export debug data for analysis +const debugData = inspector.exportDebugData() +``` + +## Performance + +The validation system is optimized for performance: + +- **JSON Schema Caching** - Schemas are cached for reuse +- **Incremental Validation** - Only validates changed parts +- **Batch Processing** - Efficient batch validation +- **Memory Management** - Automatic cleanup of validation state +- **Async Processing** - Non-blocking validation operations + +## Error Handling + +The system provides comprehensive error handling: + +- **Structured Errors** - Consistent error format with paths and codes +- **Error Classification** - Errors, warnings, and info levels +- **Context Preservation** - Maintains validation context throughout +- **Recovery Mechanisms** - Graceful handling of validation failures + +## Testing + +The system includes comprehensive testing utilities: + +```typescript +// Generate test cases from schema +const testSuite = inspector.generateTestSuiteFromSchema(schema) + +// Run automated tests +const results = inspector.runTestSuite(testSuite) + +// Validate test results +results.passed // Number of passed tests +results.failed // Number of failed tests +results.results // Detailed test results +``` + +## Contributing + +To extend the validation system: + +1. **Add New Component Types** - Update the master schema +2. **Create Custom Validators** - Implement business logic validators +3. **Add Security Rules** - Enhance security validation +4. **Extend Error Formatting** - Add new report formats +5. **Schema Migrations** - Add version migration support + +## License + +This validation system is part of the Backend-Driven UI project. \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/client-validator.ts b/packages/domain/src/schema-management/schema-validation/client-validator.ts new file mode 100644 index 0000000..6cc9dbf --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/client-validator.ts @@ -0,0 +1,483 @@ +import { SchemaValidationResult, SchemaValidationError, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { ValidationSchema } from './validation-engine.js' +import { SchemaValidationSeverity } from '../shared/enums/index.js' + +export interface ClientValidationOptions { + strict?: boolean + lenient?: boolean + skipWarnings?: boolean + maxDepth?: number + timeout?: number +} + +export interface ValidationRule { + type: 'required' | 'type' | 'min' | 'max' | 'pattern' | 'enum' | 'custom' + value?: unknown + message?: string +} + +export interface ComponentValidation { + type: string + required?: boolean + properties?: Record + children?: ComponentValidation +} + +export interface ClientSchema { + version: string + components: Record + scenarioData?: Record +} + +export class ClientValidator { + private schema: ClientSchema + private options: Required + + constructor(schema: ClientSchema, options: ClientValidationOptions = {}) { + this.schema = schema + this.options = { + strict: options.strict ?? false, + lenient: options.lenient ?? true, + skipWarnings: options.skipWarnings ?? false, + maxDepth: options.maxDepth ?? 5, + timeout: options.timeout ?? 5000, + } + } + + public validate(data: unknown, context?: SchemaValidationContext): Promise { + return new Promise((resolve) => { + const timeout = setTimeout(() => { + resolve( + SchemaValidationResult.failure([ + this.createError('Validation timeout exceeded', '$', context), + ]), + ) + }, this.options.timeout) + + try { + const result = this.validateInternal(data, context) + clearTimeout(timeout) + resolve(result) + } catch (error) { + clearTimeout(timeout) + resolve( + SchemaValidationResult.failure([ + this.createError( + `Validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`, + '$', + context, + ), + ]), + ) + } + }) + } + + public validateSync(data: unknown, context?: SchemaValidationContext): SchemaValidationResult { + try { + return this.validateInternal(data, context) + } catch (error) { + return SchemaValidationResult.failure([ + this.createError( + `Validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`, + '$', + context, + ), + ]) + } + } + + public validateComponent(component: unknown, context?: SchemaValidationContext): SchemaValidationResult { + if (typeof component !== 'object' || component === null || Array.isArray(component)) { + return SchemaValidationResult.failure([ + this.createError('Component must be an object', '$', context), + ]) + } + + const comp = component as Record + const componentType = comp.type as string + + if (!componentType) { + return SchemaValidationResult.failure([ + this.createError('Component must have a type', '$.type', context), + ]) + } + + const validation = this.schema.components[componentType] + if (!validation) { + if (this.options.strict) { + return SchemaValidationResult.failure([ + this.createError(`Unknown component type: ${componentType}`, '$.type', context), + ]) + } else { + // In lenient mode, allow unknown component types + return SchemaValidationResult.success(context) + } + } + + let result = SchemaValidationResult.success(context) + + // Validate required properties + if (validation.required) { + const requiredProps = this.getRequiredProperties(validation) + for (const prop of requiredProps) { + if (!(prop in comp)) { + result = SchemaValidationResult.failure([ + this.createError(`Required property missing: ${prop}`, `$.${prop}`, context), + ]) + } + } + } + + // Validate properties + if (comp.props && typeof comp.props === 'object') { + const propsResult = this.validateProperties(comp.props as Record, validation, context) + result = result.merge(propsResult) + } + + // Validate children recursively + if (comp.children && Array.isArray(comp.children)) { + const childrenResult = this.validateChildren(comp.children, validation.children, context) + result = result.merge(childrenResult) + } + + return result + } + + public validateScenarioData(data: Record, context?: SchemaValidationContext): SchemaValidationResult { + let result = SchemaValidationResult.success(context) + + for (const [key, value] of Object.entries(data)) { + const rules = this.schema.scenarioData?.[key] + if (rules) { + const valueResult = this.validateValue(value, rules, context) + result = result.merge(valueResult) + } + } + + return result + } + + public sanitizeData(data: unknown): unknown { + if (data === null || data === undefined) { + return data + } + + if (typeof data === 'string') { + return this.sanitizeString(data) + } + + if (Array.isArray(data)) { + return data.map((item) => this.sanitizeData(item)) + } + + if (typeof data === 'object') { + const sanitized: Record = {} + for (const [key, value] of Object.entries(data)) { + sanitized[key] = this.sanitizeData(value) + } + return sanitized + } + + return data + } + + public getDefaultValue(componentType: string, property: string): unknown { + const validation = this.schema.components[componentType] + if (!validation?.properties?.[property]) { + return undefined + } + + const rules = validation.properties[property] + for (const rule of rules) { + if (rule.type === 'required' && rule.value !== undefined) { + return rule.value + } + } + + return undefined + } + + public isValidComponentType(componentType: string): boolean { + return componentType in this.schema.components + } + + public getSupportedComponentTypes(): string[] { + return Object.keys(this.schema.components) + } + + public getComponentSchema(componentType: string): ComponentValidation | null { + return this.schema.components[componentType] || null + } + + private validateInternal(data: unknown, context?: SchemaValidationContext): SchemaValidationResult { + if (typeof data !== 'object' || data === null || Array.isArray(data)) { + return SchemaValidationResult.failure([ + this.createError('Data must be an object', '$', context), + ]) + } + + const config = data as Record + let result = SchemaValidationResult.success(context) + + // Validate version + if (config.version) { + if (typeof config.version !== 'string') { + result = SchemaValidationResult.failure([ + this.createError('Version must be a string', '$.version', context), + ]) + } + } + + // Validate components + if (config.components && Array.isArray(config.components)) { + const componentsResult = this.validateComponents(config.components, context) + result = result.merge(componentsResult) + } else { + result = SchemaValidationResult.failure([ + this.createError('Components must be an array', '$.components', context), + ]) + } + + // Validate scenario data + if (config.scenarioData && typeof config.scenarioData === 'object') { + const scenarioResult = this.validateScenarioData(config.scenarioData as Record, context) + result = result.merge(scenarioResult) + } + + return result + } + + private validateComponents(components: unknown[], context?: SchemaValidationContext): SchemaValidationResult { + let result = SchemaValidationResult.success(context) + + for (let i = 0; i < components.length; i++) { + const componentResult = this.validateComponent(components[i], { + ...context, + path: `$.components[${i}]`, + }) + result = result.merge(componentResult) + } + + return result + } + + private validateProperties( + props: Record, + validation: ComponentValidation, + context?: SchemaValidationContext, + ): SchemaValidationResult { + let result = SchemaValidationResult.success(context) + + for (const [propName, propValue] of Object.entries(props)) { + const rules = validation.properties?.[propName] + if (rules) { + const valueResult = this.validateValue(propValue, rules, context) + result = result.merge(valueResult) + } + } + + return result + } + + private validateChildren( + children: unknown[], + childValidation?: ComponentValidation, + context?: SchemaValidationContext, + ): SchemaValidationResult { + let result = SchemaValidationResult.success(context) + + for (let i = 0; i < children.length; i++) { + const childResult = this.validateComponent(children[i], { + ...context, + path: context?.path ? `${context.path}.children[${i}]` : `$.children[${i}]`, + }) + result = result.merge(childResult) + } + + return result + } + + private validateValue(value: unknown, rules: ValidationRule[], context?: SchemaValidationContext): SchemaValidationResult { + let result = SchemaValidationResult.success(context) + + for (const rule of rules) { + const ruleResult = this.applyRule(value, rule, context) + if (!ruleResult.isValid) { + result = result.merge(ruleResult) + } + } + + return result + } + + private applyRule(value: unknown, rule: ValidationRule, context?: SchemaValidationContext): SchemaValidationResult { + switch (rule.type) { + case 'required': + if (value === null || value === undefined) { + return SchemaValidationResult.failure([ + this.createError(rule.message || 'Value is required', context?.path || '$', context), + ]) + } + break + + case 'type': + if (rule.value && typeof value !== rule.value) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `Value must be of type ${rule.value}`, + context?.path || '$', + context, + ), + ]) + } + break + + case 'min': + if (typeof value === 'number' && typeof rule.value === 'number' && value < rule.value) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `Value must be at least ${rule.value}`, + context?.path || '$', + context, + ), + ]) + } + if (typeof value === 'string' && typeof rule.value === 'number' && value.length < rule.value) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `String must be at least ${rule.value} characters`, + context?.path || '$', + context, + ), + ]) + } + break + + case 'max': + if (typeof value === 'number' && typeof rule.value === 'number' && value > rule.value) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `Value must be at most ${rule.value}`, + context?.path || '$', + context, + ), + ]) + } + if (typeof value === 'string' && typeof rule.value === 'number' && value.length > rule.value) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `String must be at most ${rule.value} characters`, + context?.path || '$', + context, + ), + ]) + } + break + + case 'pattern': + if (typeof value === 'string' && rule.value && typeof rule.value === 'string') { + const regex = new RegExp(rule.value) + if (!regex.test(value)) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `Value does not match pattern ${rule.value}`, + context?.path || '$', + context, + ), + ]) + } + } + break + + case 'enum': + if (rule.value && Array.isArray(rule.value) && !rule.value.includes(value)) { + return SchemaValidationResult.failure([ + this.createError( + rule.message || `Value must be one of: ${rule.value.join(', ')}`, + context?.path || '$', + context, + ), + ]) + } + break + + case 'custom': + // Custom validation would require a callback function + break + } + + return SchemaValidationResult.success(context) + } + + private getRequiredProperties(validation: ComponentValidation): string[] { + const required: string[] = [] + + if (validation.properties) { + for (const [propName, rules] of Object.entries(validation.properties)) { + for (const rule of rules) { + if (rule.type === 'required') { + required.push(propName) + break + } + } + } + } + + return required + } + + private sanitizeString(input: string): string { + // Basic sanitization for client-side + return input + .replace(/)<[^<]*)*<\/script>/gi, '') + .replace(/javascript:/gi, '') + .replace(/on\w+\s*=/gi, '') + .trim() + } + + private createError(message: string, path: string, context?: SchemaValidationContext): SchemaValidationError { + return { + id: `client_error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'CLIENT_VALIDATION_ERROR', + message, + path, + severity: SchemaValidationSeverity.ERROR, + timestamp: new Date(), + } + } + + public static create(schema: ClientSchema, options?: ClientValidationOptions): ClientValidator { + return new ClientValidator(schema, options) + } + + public static createFromJSONSchema(jsonSchema: ValidationSchema): ClientValidator { + const clientSchema: ClientSchema = { + version: '1.0.0', + components: {}, + } + + // Convert JSON schema to client schema format + if (jsonSchema.definitions?.component) { + // This is a simplified conversion - in practice you'd need more comprehensive mapping + clientSchema.components = { + Button: { + required: true, + properties: { + text: [{ type: 'required' }], + type: [{ type: 'type', value: 'string' }], + }, + }, + Label: { + required: true, + properties: { + text: [{ type: 'required' }], + type: [{ type: 'type', value: 'string' }], + }, + }, + } + } + + return new ClientValidator(clientSchema) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/custom-validators.ts b/packages/domain/src/schema-management/schema-validation/custom-validators.ts new file mode 100644 index 0000000..072ca5a --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/custom-validators.ts @@ -0,0 +1,381 @@ +import { SchemaValidationResult, SchemaValidationError, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { CustomValidator, ValidationEngine } from './validation-engine.js' +import { SchemaValidationSeverity } from '../shared/enums/index.js' + +export class SecurityValidator implements CustomValidator { + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + const errors: SchemaValidationError[] = [] + + if (typeof value === 'string') { + // Check for potentially dangerous content + const dangerousPatterns = [ + /]*>.*?<\/script>/gi, + /javascript:/gi, + /vbscript:/gi, + /onload\s*=/gi, + /onerror\s*=/gi, + /onclick\s*=/gi, + ] + + for (const pattern of dangerousPatterns) { + if (pattern.test(value)) { + errors.push({ + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'SECURITY_THREAT', + message: 'Potentially dangerous content detected', + path: context?.path || '', + severity: SchemaValidationSeverity.ERROR, + details: { pattern: pattern.toString(), value: value.substring(0, 100) }, + timestamp: new Date(), + }) + } + } + + // Check for SQL injection patterns + const sqlPatterns = [ + /(\bselect\b|\binsert\b|\bupdate\b|\bdelete\b|\bdrop\b|\bunion\b|\bscript\b)/gi, + ] + + for (const pattern of sqlPatterns) { + if (pattern.test(value)) { + errors.push({ + id: `sql_injection_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'SQL_INJECTION_RISK', + message: 'Potential SQL injection pattern detected', + path: context?.path || '', + severity: SchemaValidationSeverity.WARNING, + details: { pattern: pattern.toString(), value: value.substring(0, 100) }, + timestamp: new Date(), + }) + } + } + } + + if (errors.length > 0) { + return SchemaValidationResult.failure(errors) + } + + return SchemaValidationResult.success(context) + } +} + +export class ComponentTypeValidator implements CustomValidator { + private allowedTypes: Set + + constructor(allowedTypes: string[]) { + this.allowedTypes = new Set(allowedTypes) + } + + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + if (typeof value !== 'object' || value === null || Array.isArray(value)) { + return SchemaValidationResult.success(context) + } + + const component = value as Record + const componentType = component.type as string + + if (!componentType || !this.allowedTypes.has(componentType)) { + return SchemaValidationResult.failure([ + { + id: `component_type_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'INVALID_COMPONENT_TYPE', + message: `Component type '${componentType}' is not allowed. Allowed types: ${Array.from(this.allowedTypes).join(', ')}`, + path: context?.path || '', + severity: SchemaValidationSeverity.ERROR, + details: { componentType, allowedTypes: Array.from(this.allowedTypes) }, + timestamp: new Date(), + }, + ]) + } + + return SchemaValidationResult.success(context) + } +} + +export class URLValidator implements CustomValidator { + private allowedProtocols: Set + private requireHttps: boolean + + constructor(options: { allowedProtocols?: string[]; requireHttps?: boolean } = {}) { + this.allowedProtocols = new Set(options.allowedProtocols || ['https:', 'http:']) + this.requireHttps = options.requireHttps || false + } + + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + if (typeof value !== 'string') { + return SchemaValidationResult.success(context) + } + + try { + const url = new URL(value) + + if (!this.allowedProtocols.has(url.protocol)) { + return SchemaValidationResult.failure([ + { + id: `url_protocol_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'INVALID_URL_PROTOCOL', + message: `URL protocol '${url.protocol}' is not allowed. Allowed protocols: ${Array.from(this.allowedProtocols).join(', ')}`, + path: context?.path || '', + severity: SchemaValidationSeverity.ERROR, + details: { url: value, protocol: url.protocol, allowedProtocols: Array.from(this.allowedProtocols) }, + timestamp: new Date(), + }, + ]) + } + + if (this.requireHttps && url.protocol !== 'https:') { + return SchemaValidationResult.failure([ + { + id: `url_https_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'HTTPS_REQUIRED', + message: 'URL must use HTTPS protocol', + path: context?.path || '', + severity: SchemaValidationSeverity.ERROR, + details: { url: value, protocol: url.protocol }, + timestamp: new Date(), + }, + ]) + } + + return SchemaValidationResult.success(context) + } catch { + return SchemaValidationResult.failure([ + { + id: `url_format_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'INVALID_URL_FORMAT', + message: 'Invalid URL format', + path: context?.path || '', + severity: SchemaValidationSeverity.ERROR, + details: { url: value }, + timestamp: new Date(), + }, + ]) + } + } +} + +export class ColorValidator implements CustomValidator { + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + if (typeof value !== 'string') { + return SchemaValidationResult.success(context) + } + + // Check hex color format + const hexColorRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/ + const isValidHex = hexColorRegex.test(value) + + if (!isValidHex) { + return SchemaValidationResult.failure([ + { + id: `color_format_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'INVALID_COLOR_FORMAT', + message: 'Color must be in hex format (#RRGGBB or #RRGGBBAA)', + path: context?.path || '', + severity: SchemaValidationSeverity.ERROR, + details: { color: value }, + timestamp: new Date(), + }, + ]) + } + + return SchemaValidationResult.success(context) + } +} + +export class BusinessLogicValidator implements CustomValidator { + private rules: Array<{ + condition: (value: unknown, context?: SchemaValidationContext) => boolean + message: string + severity: SchemaValidationSeverity + }> + + constructor(rules: Array<{ + condition: (value: unknown, context?: SchemaValidationContext) => boolean + message: string + severity?: SchemaValidationSeverity + }>) { + this.rules = rules.map((rule) => ({ + ...rule, + severity: rule.severity || SchemaValidationSeverity.ERROR, + })) + } + + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + const errors: SchemaValidationError[] = [] + + for (const rule of this.rules) { + if (!rule.condition(value, context)) { + errors.push({ + id: `business_logic_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'BUSINESS_LOGIC_VIOLATION', + message: rule.message, + path: context?.path || '', + severity: rule.severity, + details: { value, context }, + timestamp: new Date(), + }) + } + } + + if (errors.length > 0) { + return SchemaValidationResult.failure(errors) + } + + return SchemaValidationResult.success(context) + } + + public static createButtonLogicValidator(): BusinessLogicValidator { + return new BusinessLogicValidator([ + { + condition: (value: unknown) => { + if (typeof value !== 'object' || value === null || Array.isArray(value)) return true + const component = value as Record + return !!(component.type === 'Button' && component.props && typeof component.props === 'object' && 'text' in component.props) + }, + message: 'Button component must have a text property', + severity: SchemaValidationSeverity.ERROR, + }, + { + condition: (value: unknown) => { + if (typeof value !== 'object' || value === null || Array.isArray(value)) return true + const component = value as Record + if (component.type !== 'Button') return true + + const props = component.props as Record | undefined + if (!props || !('onClick' in props)) return true + + const onClick = props.onClick as string + return onClick.startsWith('action:') + }, + message: 'Button onClick must start with "action:"', + severity: SchemaValidationSeverity.ERROR, + }, + ]) + } + + public static createImageLogicValidator(): BusinessLogicValidator { + return new BusinessLogicValidator([ + { + condition: (value: unknown) => { + if (typeof value !== 'object' || value === null || Array.isArray(value)) return true + const component = value as Record + if (component.type !== 'Image') return true + + const props = component.props as Record | undefined + if (!props || !('src' in props)) return true + + const src = props.src as string + try { + const url = new URL(src) + return url.protocol === 'https:' + } catch { + return false + } + }, + message: 'Image src must use HTTPS protocol', + severity: SchemaValidationSeverity.ERROR, + }, + ]) + } +} + +export class CrossFieldValidator implements CustomValidator { + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + const errors: SchemaValidationError[] = [] + + if (typeof value === 'object' && value !== null && !Array.isArray(value)) { + const component = value as Record + + // Validate Button component cross-field rules + if (component.type === 'Button') { + const props = component.props as Record | undefined + + if (props) { + // If disabled is true, should not have onClick + if (props.disabled === true && props.onClick) { + errors.push({ + id: `cross_field_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'BUTTON_DISABLED_WITH_ONCLICK', + message: 'Disabled button should not have onClick handler', + path: context?.path || '', + severity: SchemaValidationSeverity.WARNING, + details: { disabled: true, hasOnClick: true }, + timestamp: new Date(), + }) + } + + // If variant is 'ghost', should have appropriate styling + if (props.variant === 'ghost' && (!props.styles || typeof props.styles !== 'object')) { + errors.push({ + id: `cross_field_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'BUTTON_GHOST_NEEDS_STYLES', + message: 'Ghost button variant typically requires custom styling', + path: context?.path || '', + severity: SchemaValidationSeverity.INFO, + details: { variant: 'ghost', hasStyles: false }, + timestamp: new Date(), + }) + } + } + } + + // Validate List component cross-field rules + if (component.type === 'List') { + const props = component.props as Record | undefined + + if (props && props.items && Array.isArray(props.items)) { + if (props.items.length === 0 && props.direction) { + errors.push({ + id: `cross_field_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'LIST_EMPTY_WITH_DIRECTION', + message: 'Empty list does not need direction property', + path: context?.path || '', + severity: SchemaValidationSeverity.INFO, + details: { itemCount: 0, hasDirection: true }, + timestamp: new Date(), + }) + } + } + } + } + + if (errors.length > 0) { + return SchemaValidationResult.failure(errors) + } + + return SchemaValidationResult.success(context) + } +} + +export class CustomValidatorsRegistry { + private validators: Map = new Map() + + constructor() { + this.register('security', new SecurityValidator()) + this.register('componentType', new ComponentTypeValidator([ + 'Button', 'Label', 'Text', 'Image', 'List', 'Banner', 'Container', 'Row', 'Column', 'Card', + 'Form', 'Input', 'Select', 'Checkbox', 'Radio', 'Modal', 'Alert', 'Progress', 'Icon' + ])) + this.register('url', new URLValidator({ requireHttps: true })) + this.register('color', new ColorValidator()) + this.register('buttonLogic', BusinessLogicValidator.createButtonLogicValidator()) + this.register('imageLogic', BusinessLogicValidator.createImageLogicValidator()) + this.register('crossField', new CrossFieldValidator()) + } + + public register(name: string, validator: CustomValidator): void { + this.validators.set(name, validator) + } + + public get(name: string): CustomValidator | null { + return this.validators.get(name) || null + } + + public getAll(): Map { + return new Map(this.validators) + } + + public createValidatorEngine(schema: ValidationEngine['schema']): ValidationEngine { + return ValidationEngine.create(schema, { customValidators: this.validators }) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/debug-inspector.ts b/packages/domain/src/schema-management/schema-validation/debug-inspector.ts new file mode 100644 index 0000000..6343b20 --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/debug-inspector.ts @@ -0,0 +1,616 @@ +import { SchemaValidationResult, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { ValidationService } from './validation.service.js' +import { ValidationEngine } from './validation-engine.js' +import { CustomValidatorsRegistry } from './custom-validators.js' + +export interface DebugInspectionData { + keyPaths: string[] + activeSubscriptions: Array<{ + id: string + keyPaths: string[] + subscriber: string + }> + patchLog: Array<{ + timestamp: Date + keyPath: string + operation: string + oldValue?: unknown + newValue?: unknown + }> + failedValidations: Array<{ + timestamp: Date + keyPath: string + value: unknown + error: string + context: SchemaValidationContext + }> + validationMetrics: { + totalValidations: number + successfulValidations: number + failedValidations: number + averageValidationTime: number + validationErrors: Record + } +} + +export interface InspectorConfig { + maxHistorySize: number + enableMetrics: boolean + enablePatchLogging: boolean + enableValidationLogging: boolean + debugMode: boolean +} + +export interface ValidationTestCase { + name: string + input: unknown + expectedResult: boolean + expectedErrors?: string[] + description?: string +} + +export interface ValidationTestSuite { + name: string + testCases: ValidationTestCase[] + schema?: any +} + +export interface ValidationDebugInfo { + executionTime: number + steps: Array<{ + step: string + duration: number + result: 'pass' | 'fail' + message?: string + }> + intermediateResults: Array<{ + stage: string + result: SchemaValidationResult + }> +} + +export class DebugInspector { + private validationService: ValidationService + private engine: ValidationEngine + private customValidators: CustomValidatorsRegistry + private config: InspectorConfig + private inspectionData: DebugInspectionData + private isEnabled: boolean + + constructor( + validationService: ValidationService, + config: InspectorConfig = { + maxHistorySize: 1000, + enableMetrics: true, + enablePatchLogging: true, + enableValidationLogging: true, + debugMode: false, + }, + ) { + this.validationService = validationService + this.engine = ValidationEngine.create(validationService.getSchema()) + this.customValidators = new CustomValidatorsRegistry() + this.config = config + this.isEnabled = config.debugMode + + this.inspectionData = { + keyPaths: [], + activeSubscriptions: [], + patchLog: [], + failedValidations: [], + validationMetrics: { + totalValidations: 0, + successfulValidations: 0, + failedValidations: 0, + averageValidationTime: 0, + validationErrors: {}, + }, + } + } + + public enable(): void { + this.isEnabled = true + } + + public disable(): void { + this.isEnabled = false + } + + public isDebugEnabled(): boolean { + return this.isEnabled + } + + public async inspectValidation( + data: unknown, + context?: SchemaValidationContext, + debugName?: string, + ): Promise<{ + result: SchemaValidationResult + debugInfo: ValidationDebugInfo + }> { + if (!this.isEnabled) { + const result = await this.validationService.validate({ data, context }) + return { result, debugInfo: { executionTime: 0, steps: [], intermediateResults: [] } } + } + + const startTime = Date.now() + const steps: ValidationDebugInfo['steps'] = [] + const intermediateResults: ValidationDebugInfo['intermediateResults'] = [] + + this.recordStep(steps, 'Validation started', startTime) + + // Step 1: Basic schema validation + const schemaValidationStart = Date.now() + const schemaResult = await this.engine.validate(data, context) + this.recordStep(steps, 'Schema validation', schemaValidationStart, schemaResult.isValid ? 'pass' : 'fail') + intermediateResults.push({ stage: 'schema_validation', result: schemaResult }) + + // Step 2: Custom validators + let finalResult = schemaResult + if (schemaResult.isValid) { + const customValidationStart = Date.now() + const customValidators = this.customValidators.getAll() + + for (const [name, validator] of customValidators) { + try { + const customResult = await validator.validate(data, context) + finalResult = finalResult.merge(customResult) + + if (!customResult.isValid) { + this.recordStep(steps, `Custom validator: ${name}`, customValidationStart, 'fail', customResult.errors[0]?.message) + } else { + this.recordStep(steps, `Custom validator: ${name}`, customValidationStart, 'pass') + } + } catch (error) { + this.recordStep(steps, `Custom validator: ${name}`, customValidationStart, 'fail', error instanceof Error ? error.message : 'Unknown error') + } + } + } + + const executionTime = Date.now() - startTime + this.recordStep(steps, 'Validation completed', startTime, finalResult.isValid ? 'pass' : 'fail') + + // Update metrics + if (this.config.enableMetrics) { + this.updateValidationMetrics(finalResult, executionTime) + } + + // Log failed validation if enabled + if (this.config.enableValidationLogging && !finalResult.isValid) { + this.logFailedValidation(data, finalResult, context, debugName) + } + + return { + result: finalResult, + debugInfo: { + executionTime, + steps, + intermediateResults, + }, + } + } + + public runTestSuite(testSuite: ValidationTestSuite): { + passed: number + failed: number + results: Array<{ + testCase: ValidationTestCase + result: boolean + errors: string[] + executionTime: number + }> + } { + if (!this.isEnabled) { + return { passed: 0, failed: 0, results: [] } + } + + const results = [] + let passed = 0 + let failed = 0 + + for (const testCase of testSuite.testCases) { + const startTime = Date.now() + const validationEngine = testSuite.schema + ? ValidationEngine.create(testSuite.schema) + : this.engine + + const result = validationEngine.validateSync({ + data: testCase.input, + options: { strict: true }, + }) + + const executionTime = Date.now() - startTime + const testPassed = result.isValid === testCase.expectedResult + + if (testPassed) { + passed++ + } else { + failed++ + } + + results.push({ + testCase, + result: testPassed, + errors: result.errors.map((e) => e.message), + executionTime, + }) + } + + return { passed, failed, results } + } + + public getInspectionData(): DebugInspectionData { + return { ...this.inspectionData } + } + + public getKeyPaths(): string[] { + return [...this.inspectionData.keyPaths] + } + + public getActiveSubscriptions(): Array<{ + id: string + keyPaths: string[] + subscriber: string + }> { + return [...this.inspectionData.activeSubscriptions] + } + + public getPatchLog(limit?: number): Array<{ + timestamp: Date + keyPath: string + operation: string + oldValue?: unknown + newValue?: unknown + }> { + const log = [...this.inspectionData.patchLog] + return limit ? log.slice(-limit) : log + } + + public getFailedValidations(limit?: number): Array<{ + timestamp: Date + keyPath: string + value: unknown + error: string + context: SchemaValidationContext + }> { + const log = [...this.inspectionData.failedValidations] + return limit ? log.slice(-limit) : log + } + + public getValidationMetrics(): DebugInspectionData['validationMetrics'] { + return { ...this.inspectionData.validationMetrics } + } + + public clearInspectionData(): void { + this.inspectionData = { + keyPaths: [], + activeSubscriptions: [], + patchLog: [], + failedValidations: [], + validationMetrics: { + totalValidations: 0, + successfulValidations: 0, + failedValidations: 0, + averageValidationTime: 0, + validationErrors: {}, + }, + } + } + + public recordKeyPath(keyPath: string): void { + if (!this.inspectionData.keyPaths.includes(keyPath)) { + this.inspectionData.keyPaths.push(keyPath) + } + } + + public recordSubscription( + id: string, + keyPaths: string[], + subscriber: string, + ): void { + const subscription = { + id, + keyPaths: [...keyPaths], + subscriber, + } + + this.inspectionData.activeSubscriptions.push(subscription) + } + + public removeSubscription(id: string): void { + this.inspectionData.activeSubscriptions = this.inspectionData.activeSubscriptions.filter( + (sub) => sub.id !== id, + ) + } + + public recordPatch( + keyPath: string, + operation: string, + oldValue?: unknown, + newValue?: unknown, + ): void { + if (!this.config.enablePatchLogging) return + + const patch = { + timestamp: new Date(), + keyPath, + operation, + oldValue, + newValue, + } + + this.inspectionData.patchLog.push(patch) + + // Trim to max history size + if (this.inspectionData.patchLog.length > this.config.maxHistorySize) { + this.inspectionData.patchLog = this.inspectionData.patchLog.slice(-this.config.maxHistorySize) + } + } + + public generateTestSuiteFromSchema(schema: any): ValidationTestSuite { + const testCases: ValidationTestCase[] = [] + + // Generate test cases based on schema structure + if (schema.type === 'object' && schema.properties) { + for (const [propName, propSchema] of Object.entries(schema.properties)) { + testCases.push({ + name: `Valid ${propName}`, + input: this.generateValidValueForSchema(propSchema), + expectedResult: true, + description: `Valid value for property ${propName}`, + }) + + testCases.push({ + name: `Invalid ${propName}`, + input: this.generateInvalidValueForSchema(propSchema), + expectedResult: false, + description: `Invalid value for property ${propName}`, + }) + } + } + + return { + name: `Auto-generated from schema (${Date.now()})`, + testCases, + schema, + } + } + + public exportDebugData(): string { + return JSON.stringify(this.inspectionData, null, 2) + } + + public importDebugData(data: string): void { + try { + const parsed = JSON.parse(data) + this.inspectionData = { ...parsed } + } catch (error) { + throw new Error(`Failed to import debug data: ${error instanceof Error ? error.message : 'Unknown error'}`) + } + } + + public generateHTMLReport(): string { + const data = this.inspectionData + + return ` + + + + Validation Debug Inspector + + + +

Validation Debug Inspector

+ +
+

Validation Metrics

+
+
+

Total Validations

+
${data.validationMetrics.totalValidations}
+
+
+

Successful

+
${data.validationMetrics.successfulValidations}
+
+
+

Failed

+
${data.validationMetrics.failedValidations}
+
+
+

Average Time

+
${data.validationMetrics.averageValidationTime.toFixed(2)}ms
+
+
+
+ +
+

Active Key Paths (${data.keyPaths.length})

+ 
${data.keyPaths.join('\n')}
+
+ +
+

Active Subscriptions (${data.activeSubscriptions.length})

+
+ ${data.activeSubscriptions + .map( + (sub) => ` +
+
ID: ${sub.id}
+
Subscriber: ${sub.subscriber}
+
Paths: ${sub.keyPaths.join(', ')}
+
+ `, + ) + .join('')} +
+
+ +
+

Recent Patches (${data.patchLog.length})

+
+ ${data.patchLog + .slice(-10) + .map( + (patch) => ` +
+
${patch.timestamp.toISOString()}
+
${patch.operation}: ${patch.keyPath}
+
Old: ${JSON.stringify(patch.oldValue)}
+
New: ${JSON.stringify(patch.newValue)}
+
+ `, + ) + .join('')} +
+
+ +
+

Failed Validations (${data.failedValidations.length})

+
+ ${data.failedValidations + .slice(-5) + .map( + (failure) => ` +
+
${failure.timestamp.toISOString()}
+
${failure.error}
+
Path: ${failure.keyPath}
+
Value: ${JSON.stringify(failure.value)}
+
+ `, + ) + .join('')} +
+
+ +
+

Error Distribution

+ 
${JSON.stringify(data.validationMetrics.validationErrors, null, 2)}
+
+ +` + } + + private recordStep( + steps: ValidationDebugInfo['steps'], + step: string, + startTime: number, + result: 'pass' | 'fail', + message?: string, + ): void { + const duration = Date.now() - startTime + steps.push({ + step, + duration, + result, + message, + }) + } + + private updateValidationMetrics(result: SchemaValidationResult, executionTime: number): void { + this.inspectionData.validationMetrics.totalValidations++ + + if (result.isValid) { + this.inspectionData.validationMetrics.successfulValidations++ + } else { + this.inspectionData.validationMetrics.failedValidations++ + } + + // Update average validation time + const totalTime = this.inspectionData.validationMetrics.averageValidationTime * + (this.inspectionData.validationMetrics.totalValidations - 1) + executionTime + this.inspectionData.validationMetrics.averageValidationTime = totalTime / this.inspectionData.validationMetrics.totalValidations + + // Update error counts + for (const error of result.errors) { + this.inspectionData.validationMetrics.validationErrors[error.code] = + (this.inspectionData.validationMetrics.validationErrors[error.code] || 0) + 1 + } + } + + private logFailedValidation( + data: unknown, + result: SchemaValidationResult, + context?: SchemaValidationContext, + debugName?: string, + ): void { + for (const error of result.errors) { + this.inspectionData.failedValidations.push({ + timestamp: new Date(), + keyPath: error.path || '', + value: data, + error: error.message, + context: context || { timestamp: new Date() }, + }) + + // Trim to max history size + if (this.inspectionData.failedValidations.length > this.config.maxHistorySize) { + this.inspectionData.failedValidations = this.inspectionData.failedValidations.slice(-this.config.maxHistorySize) + } + } + } + + private generateValidValueForSchema(schema: any): unknown { + switch (schema.type) { + case 'string': + return 'test_value' + case 'number': + return 42 + case 'integer': + return 42 + case 'boolean': + return true + case 'array': + return [this.generateValidValueForSchema(schema.items || { type: 'string' })] + case 'object': + const obj: Record = {} + if (schema.properties) { + for (const [key, propSchema] of Object.entries(schema.properties)) { + obj[key] = this.generateValidValueForSchema(propSchema) + } + } + return obj + default: + return 'test_value' + } + } + + private generateInvalidValueForSchema(schema: any): unknown { + switch (schema.type) { + case 'string': + return 123 // Invalid: number instead of string + case 'number': + return 'not_a_number' // Invalid: string instead of number + case 'boolean': + return 'true' // Invalid: string instead of boolean + case 'array': + return 'not_an_array' // Invalid: string instead of array + case 'object': + return [] // Invalid: array instead of object + default: + return null + } + } + + public static create( + validationService: ValidationService, + config?: InspectorConfig, + ): DebugInspector { + return new DebugInspector(validationService, config) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/error-formatter.ts b/packages/domain/src/schema-management/schema-validation/error-formatter.ts new file mode 100644 index 0000000..8ca5350 --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/error-formatter.ts @@ -0,0 +1,463 @@ +import { SchemaValidationResult, SchemaValidationError, SchemaValidationReport } from './value-objects/validation-result.vo.js' + +export interface FormattedError { + path: string + expected: string + received: unknown + message: string + code?: string + severity: string + details?: Record +} + +export interface FormattedValidationReport { + isValid: boolean + summary: { + totalErrors: number + totalWarnings: number + totalInfo: number + hasCriticalErrors: boolean + duration?: number + } + errors: FormattedError[] + warnings: FormattedError[] + info: FormattedError[] + recommendations: string[] +} + +export interface ErrorFormattingOptions { + includeCode?: boolean + includeSeverity?: boolean + includeDetails?: boolean + includeStackTrace?: boolean + maxMessageLength?: number + groupByPath?: boolean + sortBy?: 'path' | 'severity' | 'message' + filterBySeverity?: string[] +} + +export class ErrorFormatter { + private options: Required + + constructor(options: ErrorFormattingOptions = {}) { + this.options = { + includeCode: options.includeCode ?? true, + includeSeverity: options.includeSeverity ?? true, + includeDetails: options.includeDetails ?? true, + includeStackTrace: options.includeStackTrace ?? false, + maxMessageLength: options.maxMessageLength ?? 200, + groupByPath: options.groupByPath ?? false, + sortBy: options.sortBy ?? 'path', + filterBySeverity: options.filterBySeverity ?? ['error', 'warning', 'info'], + } + } + + public formatError(error: SchemaValidationError): FormattedError { + const formatted: FormattedError = { + path: error.path || 'unknown', + expected: this.extractExpectedValue(error), + received: this.extractReceivedValue(error), + message: this.truncateMessage(error.message), + severity: error.severity, + } + + if (this.options.includeCode && error.code) { + formatted.code = error.code + } + + if (this.options.includeDetails && error.details) { + formatted.details = error.details + } + + return formatted + } + + public formatReport(result: SchemaValidationResult): FormattedValidationReport { + const errors = result.errors.map((error) => this.formatError(error)) + const warnings = result.warnings.map((warning) => this.formatError(warning)) + const info = result.info.map((info) => this.formatError(info)) + + // Apply filtering + const filteredErrors = this.options.filterBySeverity.includes('error') ? errors : [] + const filteredWarnings = this.options.filterBySeverity.includes('warning') ? warnings : [] + const filteredInfo = this.options.filterBySeverity.includes('info') ? info : [] + + // Apply sorting + const allFormatted = [...filteredErrors, ...filteredWarnings, ...filteredInfo] + const sortedFormatted = this.sortFormattedErrors(allFormatted) + + // Group by path if requested + let finalErrors: FormattedError[] + let finalWarnings: FormattedError[] + let finalInfo: FormattedError[] + + if (this.options.groupByPath) { + const grouped = this.groupErrorsByPath(sortedFormatted) + finalErrors = grouped.errors + finalWarnings = grouped.warnings + finalInfo = grouped.info + } else { + finalErrors = sortedFormatted.filter((e) => e.severity === 'error') + finalWarnings = sortedFormatted.filter((w) => w.severity === 'warning') + finalInfo = sortedFormatted.filter((i) => i.severity === 'info') + } + + const hasCriticalErrors = result.hasCriticalErrors + const recommendations = this.generateRecommendations(result) + + return { + isValid: result.isValid, + summary: { + totalErrors: finalErrors.length, + totalWarnings: finalWarnings.length, + totalInfo: finalInfo.length, + hasCriticalErrors, + duration: result.duration || undefined, + }, + errors: finalErrors, + warnings: finalWarnings, + info: finalInfo, + recommendations, + } + } + + public formatForAdminUI(result: SchemaValidationResult): object { + const formatted = this.formatReport(result) + + return { + isValid: formatted.isValid, + hasErrors: formatted.summary.totalErrors > 0, + hasWarnings: formatted.summary.totalWarnings > 0, + hasCriticalErrors: formatted.summary.hasCriticalErrors, + errorCount: formatted.summary.totalErrors, + warningCount: formatted.summary.totalWarnings, + infoCount: formatted.summary.totalInfo, + errors: formatted.errors.map((error) => ({ + path: error.path, + message: error.message, + code: error.code, + severity: error.severity, + expected: error.expected, + received: this.formatValue(error.received), + details: error.details, + })), + warnings: formatted.warnings.map((warning) => ({ + path: warning.path, + message: warning.message, + code: warning.code, + severity: warning.severity, + expected: warning.expected, + received: this.formatValue(warning.received), + details: warning.details, + })), + recommendations: formatted.recommendations, + } + } + + public formatForClientRuntime(result: SchemaValidationResult): object { + const formatted = this.formatReport(result) + + return { + valid: formatted.isValid, + errors: formatted.errors.map((error) => ({ + path: error.path, + message: error.message, + type: 'error', + })), + warnings: formatted.warnings.map((warning) => ({ + path: warning.path, + message: warning.message, + type: 'warning', + })), + } + } + + public formatForLogging(result: SchemaValidationResult): object { + const formatted = this.formatReport(result) + + return { + timestamp: new Date().toISOString(), + isValid: formatted.isValid, + summary: formatted.summary, + errorDetails: formatted.errors.map((error) => ({ + path: error.path, + message: error.message, + code: error.code, + stack: error.details?.stack, + })), + warningDetails: formatted.warnings.map((warning) => ({ + path: warning.path, + message: warning.message, + code: warning.code, + stack: warning.details?.stack, + })), + } + } + + public generateJSONReport(result: SchemaValidationResult): string { + const formatted = this.formatReport(result) + return JSON.stringify(formatted, null, 2) + } + + public generateHTMLReport(result: SchemaValidationResult): string { + const formatted = this.formatReport(result) + + const errorRows = formatted.errors + .map( + (error) => ` + + ${this.escapeHtml(error.path)} + ${this.escapeHtml(error.expected)} + ${this.escapeHtml(this.formatValue(error.received))} + ${this.escapeHtml(error.message)} + ${this.escapeHtml(error.code || '')} + `, + ) + .join('') + + const warningRows = formatted.warnings + .map( + (warning) => ` + + ${this.escapeHtml(warning.path)} + ${this.escapeHtml(warning.expected)} + ${this.escapeHtml(this.formatValue(warning.received))} + ${this.escapeHtml(warning.message)} + ${this.escapeHtml(warning.code || '')} + `, + ) + .join('') + + return ` + + + + Validation Report + + + +

Validation Report

+
+

Summary

+

Valid: ${formatted.isValid ? 'Yes' : 'No'}

+

Errors: ${formatted.summary.totalErrors}

+

Warnings: ${formatted.summary.totalWarnings}

+

Info: ${formatted.summary.totalInfo}

+

Critical Errors: ${formatted.summary.hasCriticalErrors ? 'Yes' : 'No'}

+ ${formatted.summary.duration ? `

Duration: ${formatted.summary.duration}ms

` : ''} +
+ + ${formatted.errors.length > 0 ? ` +

Errors

+ + + + + + + + + + + + ${errorRows} + +
PathExpectedReceivedMessageCode
+ ` : ''} + + ${formatted.warnings.length > 0 ? ` +

Warnings

+ + + + + + + + + + + + ${warningRows} + +
PathExpectedReceivedMessageCode
+ ` : ''} + + ${formatted.recommendations.length > 0 ? ` +
+

Recommendations

+
    + ${formatted.recommendations.map((rec) => `
  • ${this.escapeHtml(rec)}
    • `).join('')} +
+
+ ` : ''} + +` + } + + private extractExpectedValue(error: SchemaValidationError): string { + if (error.details?.expected !== undefined) { + return String(error.details.expected) + } + + // Try to extract from message + const expectedMatch = error.message.match(/expected?:?\s*([^,\n]+)/i) + if (expectedMatch) { + return expectedMatch[1].trim() + } + + return 'valid value' + } + + private extractReceivedValue(error: SchemaValidationError): unknown { + return error.details?.received ?? 'unknown' + } + + private truncateMessage(message: string): string { + if (message.length <= this.options.maxMessageLength) { + return message + } + + return message.substring(0, this.options.maxMessageLength - 3) + '...' + } + + private sortFormattedErrors(errors: FormattedError[]): FormattedError[] { + const sorted = [...errors] + + switch (this.options.sortBy) { + case 'path': + sorted.sort((a, b) => a.path.localeCompare(b.path)) + break + case 'severity': + const severityOrder = { error: 0, warning: 1, info: 2 } + sorted.sort((a, b) => severityOrder[a.severity as keyof typeof severityOrder] - severityOrder[b.severity as keyof typeof severityOrder]) + break + case 'message': + sorted.sort((a, b) => a.message.localeCompare(b.message)) + break + } + + return sorted + } + + private groupErrorsByPath(errors: FormattedError[]): { + errors: FormattedError[] + warnings: FormattedError[] + info: FormattedError[] + } { + const groups = new Map() + + for (const error of errors) { + const path = error.path + if (!groups.has(path)) { + groups.set(path, []) + } + groups.get(path)!.push(error) + } + + const result = { + errors: [] as FormattedError[], + warnings: [] as FormattedError[], + info: [] as FormattedError[], + } + + for (const [path, pathErrors] of groups) { + // Merge errors with the same path + const mergedError: FormattedError = { + path, + expected: pathErrors.map((e) => e.expected).join(' | '), + received: pathErrors[0].received, // Take the first received value + message: pathErrors.map((e) => e.message).join(' | '), + severity: pathErrors[0].severity, + code: pathErrors.map((e) => e.code || '').join(', '), + details: Object.assign({}, ...pathErrors.map((e) => e.details || {})), + } + + switch (mergedError.severity) { + case 'error': + result.errors.push(mergedError) + break + case 'warning': + result.warnings.push(mergedError) + break + case 'info': + result.info.push(mergedError) + break + } + } + + return result + } + + private generateRecommendations(result: SchemaValidationResult): string[] { + const recommendations: string[] = [] + + if (!result.isValid) { + recommendations.push('Fix all validation errors before proceeding') + + if (result.errorCount > 10) { + recommendations.push('Consider breaking down the configuration into smaller, manageable pieces') + } + + if (result.errorCount > 50) { + recommendations.push('This configuration has a high number of errors. Consider reviewing the overall structure') + } + } + + if (result.warningCount > 0) { + recommendations.push('Review warnings for potential improvements to the configuration') + } + + if (result.hasCriticalErrors) { + recommendations.push('Critical errors detected. Immediate attention required.') + } + + if (result.duration && result.duration > 5000) { + recommendations.push('Validation took longer than expected. Consider optimizing the configuration structure.') + } + + // Component-specific recommendations + if (result.errors.some((e) => e.path?.includes('Button'))) { + recommendations.push('Check Button component configurations for missing required properties') + } + + if (result.errors.some((e) => e.path?.includes('Image'))) { + recommendations.push('Check Image component configurations for valid URLs and required properties') + } + + if (result.errors.some((e) => e.path?.includes('scenarioData'))) { + recommendations.push('Review scenario data structure and value types') + } + + return recommendations + } + + private formatValue(value: unknown): string { + if (value === null) return 'null' + if (value === undefined) return 'undefined' + if (typeof value === 'string') return `"${value}"` + if (typeof value === 'object') return JSON.stringify(value) + return String(value) + } + + private escapeHtml(text: string): string { + const div = document.createElement('div') + div.textContent = text + return div.innerHTML + } + + public static create(options?: ErrorFormattingOptions): ErrorFormatter { + return new ErrorFormatter(options) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/index.ts b/packages/domain/src/schema-management/schema-validation/index.ts index 04cca6a..a59a059 100644 --- a/packages/domain/src/schema-management/schema-validation/index.ts +++ b/packages/domain/src/schema-management/schema-validation/index.ts @@ -1 +1,88 @@ -export * from './value-objects/index.js' +// Core validation engine and schema +export { ValidationEngine, ValidationSchema, CustomValidator } from './validation-engine.js' +export { default as masterSchema } from './master.schema.json' + +// Value objects and result types +export type { + SchemaValidationResult, + SchemaValidationError, + SchemaValidationWarning, + SchemaValidationInfo, + SchemaValidationContext, + SchemaValidationResultMetadata, + SchemaValidationResultJSON, + SchemaValidationSummary, + SchemaValidationReport, +} from './value-objects/validation-result.vo.js' +export { SchemaValidationResult as ValidationResult } from './value-objects/validation-result.vo.js' + +// Main validation service +export { ValidationService, type ValidationRequest, type BatchValidationRequest, type BatchValidationResult } from './validation.service.js' + +// Custom validators +export { + SecurityValidator, + ComponentTypeValidator, + URLValidator, + ColorValidator, + BusinessLogicValidator, + CrossFieldValidator, + CustomValidatorsRegistry, +} from './custom-validators.js' + +// Error formatting and reporting +export { ErrorFormatter, type FormattedError, type FormattedValidationReport, type ErrorFormattingOptions } from './error-formatter.js' + +// Store API integration +export { + StoreValidationAdapter, + type StoreValidationRule, + type StoreValidationOptions, + type StoreValue, + type StorePatch, + type StoreChange, +} from './store-integration.js' + +// Nightly validation job +export { + NightlyValidationJob, + type NightlyValidationConfig, + type ValidationJob, + type NightlyValidationReport, + type ValidationJobEvent, +} from '../../application/src/jobs/nightly-validation.job.js' + +// Debug inspector +export { DebugInspector, type DebugInspectionData, type InspectorConfig, type ValidationTestCase, type ValidationTestSuite, type ValidationDebugInfo } from './debug-inspector.js' + +// Schema versioning and migration +export { + SchemaVersionManager, + SchemaMigrationUtils, + createDefaultVersionHistory, + type SchemaVersion, + type SchemaMigration, + type SchemaVersionHistory, + type VersionedSchema, +} from './schema-versioning.js' + +// Client-side validation +export { ClientValidator, type ClientValidationOptions, type ClientSchema, type ComponentValidation, type ValidationRule } from './client-validator.js' + +// Security validation +export { SecurityValidator as SecurityValidation, type SecurityConfig, type SecurityViolation } from './security-validator.js' + +// Enums and shared types +export { + SchemaValidationSeverity, + SchemaValidationRuleType, + ComponentType, + DataTypeCategory, + PlatformSupport, + SchemaStatus, + TemplateStatus, +} from '../shared/enums/index.js' + +// Re-export from schema-definition for convenience +export { SchemaValidationRule, type SchemaValidationRuleProps } from '../schema-definition/value-objects/validation-rule.value-object.js' +export { DataType, type DataTypeProps } from '../schema-definition/value-objects/data-type.value-object.js' \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/master.schema.json b/packages/domain/src/schema-management/schema-validation/master.schema.json new file mode 100644 index 0000000..b794d74 --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/master.schema.json @@ -0,0 +1,388 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/bdui.schema.json", + "title": "Backend-Driven UI Configuration", + "description": "Master schema for UI configurations and scenario data.", + "type": "object", + "required": ["version", "components"], + "properties": { + "version": { + "type": "string", + "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$", + "description": "Semantic version of the schema" + }, + "metadata": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "description": "Unique identifier for the configuration" + }, + "createdBy": { + "type": "string", + "description": "User who created the configuration" + }, + "createdAt": { + "type": "string", + "format": "date-time", + "description": "Creation timestamp" + }, + "updatedBy": { + "type": "string", + "description": "User who last updated the configuration" + }, + "updatedAt": { + "type": "string", + "format": "date-time", + "description": "Last update timestamp" + }, + "description": { + "type": "string", + "description": "Human-readable description of the configuration" + } + }, + "additionalProperties": false + }, + "components": { + "type": "array", + "items": { "$ref": "#/definitions/component" }, + "minItems": 1, + "description": "Array of UI components" + }, + "scenarioData": { + "type": "object", + "additionalProperties": { "$ref": "#/definitions/storeValue" }, + "description": "Key-value store of dynamic scenario data" + }, + "styles": { + "type": "object", + "additionalProperties": true, + "description": "Global styles and themes" + }, + "bindings": { + "type": "object", + "additionalProperties": { "type": "string" }, + "description": "Global data bindings" + } + }, + "additionalProperties": false, + "definitions": { + "component": { + "type": "object", + "required": ["type"], + "properties": { + "id": { + "type": "string", + "description": "Unique identifier for the component" + }, + "type": { + "type": "string", + "enum": ["Button", "Label", "List", "Banner", "Text", "Image", "Container", "Row", "Column", "Card", "Form", "Input", "Select", "Checkbox", "Radio", "Modal", "Alert", "Progress", "Icon"], + "description": "Component type" + }, + "props": { + "type": "object", + "additionalProperties": true, + "description": "Component properties" + }, + "children": { + "type": "array", + "items": { "$ref": "#/definitions/component" }, + "description": "Child components" + }, + "bindings": { + "type": "object", + "additionalProperties": { "type": "string" }, + "description": "Component-specific data bindings" + }, + "styles": { + "type": "object", + "additionalProperties": true, + "description": "Component-specific styles" + }, + "validation": { + "$ref": "#/definitions/validationRules", + "description": "Validation rules for this component" + } + }, + "allOf": [{ "$ref": "#/definitions/componentRules" }], + "additionalProperties": false + }, + "componentRules": { + "oneOf": [ + { + "properties": { + "type": { "const": "Button" }, + "props": { + "type": "object", + "required": ["text"], + "properties": { + "text": { "type": "string", "minLength": 1 }, + "onClick": { "type": "string", "pattern": "^action:.+" }, + "disabled": { "type": "boolean" }, + "variant": { "type": "string", "enum": ["primary", "secondary", "outline", "ghost"] }, + "size": { "type": "string", "enum": ["sm", "md", "lg"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Label" }, + "props": { + "type": "object", + "required": ["text"], + "properties": { + "text": { "type": "string" }, + "size": { "type": "string", "enum": ["sm", "md", "lg"] }, + "color": { "type": "string", "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$" }, + "weight": { "type": "string", "enum": ["normal", "medium", "semibold", "bold"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Text" }, + "props": { + "type": "object", + "required": ["content"], + "properties": { + "content": { "type": "string" }, + "size": { "type": "string", "enum": ["xs", "sm", "md", "lg", "xl"] }, + "color": { "type": "string", "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$" }, + "align": { "type": "string", "enum": ["left", "center", "right", "justify"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Image" }, + "props": { + "type": "object", + "required": ["src"], + "properties": { + "src": { "type": "string", "format": "uri", "pattern": "^https://" }, + "alt": { "type": "string" }, + "width": { "type": ["string", "number"] }, + "height": { "type": ["string", "number"] }, + "fit": { "type": "string", "enum": ["cover", "contain", "fill", "none", "scale-down"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "List" }, + "props": { + "type": "object", + "required": ["items"], + "properties": { + "items": { + "type": "array", + "items": { "$ref": "#/definitions/component" } + }, + "direction": { "type": "string", "enum": ["vertical", "horizontal"] }, + "spacing": { "type": ["string", "number"] }, + "divider": { "type": "boolean" } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Banner" }, + "props": { + "type": "object", + "required": ["imageUrl"], + "properties": { + "imageUrl": { "type": "string", "format": "uri", "pattern": "^https://" }, + "action": { "type": "string", "pattern": "^action:.+" }, + "title": { "type": "string" }, + "subtitle": { "type": "string" }, + "variant": { "type": "string", "enum": ["default", "success", "warning", "error", "info"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Container" }, + "props": { + "type": "object", + "properties": { + "padding": { "type": ["string", "number"] }, + "margin": { "type": ["string", "number"] }, + "backgroundColor": { "type": "string", "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$" }, + "borderRadius": { "type": ["string", "number"] }, + "maxWidth": { "type": ["string", "number"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Card" }, + "props": { + "type": "object", + "properties": { + "title": { "type": "string" }, + "subtitle": { "type": "string" }, + "elevation": { "type": "number", "minimum": 0, "maximum": 24 }, + "padding": { "type": ["string", "number"] }, + "borderRadius": { "type": ["string", "number"] } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Input" }, + "props": { + "type": "object", + "properties": { + "placeholder": { "type": "string" }, + "type": { "type": "string", "enum": ["text", "email", "password", "number", "tel", "url"] }, + "required": { "type": "boolean" }, + "disabled": { "type": "boolean" }, + "maxLength": { "type": "number", "minimum": 1 }, + "pattern": { "type": "string" } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Select" }, + "props": { + "type": "object", + "required": ["options"], + "properties": { + "options": { + "type": "array", + "items": { + "type": "object", + "properties": { + "label": { "type": "string" }, + "value": { "type": ["string", "number", "boolean"] } + }, + "required": ["label", "value"] + } + }, + "placeholder": { "type": "string" }, + "multiple": { "type": "boolean" }, + "disabled": { "type": "boolean" } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Modal" }, + "props": { + "type": "object", + "required": ["content"], + "properties": { + "content": { "$ref": "#/definitions/component" }, + "title": { "type": "string" }, + "size": { "type": "string", "enum": ["sm", "md", "lg", "xl", "full"] }, + "closable": { "type": "boolean" }, + "maskClosable": { "type": "boolean" } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Alert" }, + "props": { + "type": "object", + "required": ["message"], + "properties": { + "message": { "type": "string" }, + "type": { "type": "string", "enum": ["info", "success", "warning", "error"] }, + "closable": { "type": "boolean" }, + "showIcon": { "type": "boolean" } + }, + "additionalProperties": false + } + } + }, + { + "properties": { + "type": { "const": "Progress" }, + "props": { + "type": "object", + "required": ["percent"], + "properties": { + "percent": { "type": "number", "minimum": 0, "maximum": 100 }, + "status": { "type": "string", "enum": ["normal", "success", "exception", "active"] }, + "strokeColor": { "type": "string", "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$" }, + "showInfo": { "type": "boolean" } + }, + "additionalProperties": false + } + } + } + ] + }, + "validationRules": { + "type": "object", + "properties": { + "required": { "type": "boolean" }, + "rules": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type": { "type": "string" }, + "value": { }, + "message": { "type": "string" } + }, + "required": ["type"] + } + } + }, + "additionalProperties": false + }, + "storeValue": { + "oneOf": [ + { "type": "string" }, + { "type": "number" }, + { "type": "integer" }, + { "type": "boolean" }, + { + "type": "string", + "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$" + }, + { + "type": "string", + "format": "uri", + "pattern": "^https://" + }, + { + "type": "array", + "items": { "$ref": "#/definitions/storeValue" } + }, + { + "type": "object", + "additionalProperties": { "$ref": "#/definitions/storeValue" } + }, + { "type": "null" } + ] + } + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/schema-versioning.ts b/packages/domain/src/schema-management/schema-validation/schema-versioning.ts new file mode 100644 index 0000000..8f0575c --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/schema-versioning.ts @@ -0,0 +1,434 @@ +import { ValidationSchema } from './validation-engine.js' + +export interface SchemaVersion { + major: number + minor: number + patch: number + build?: string +} + +export interface SchemaMigration { + fromVersion: SchemaVersion + toVersion: SchemaVersion + description: string + breaking: boolean + migrationFn: (data: unknown) => unknown +} + +export interface SchemaVersionHistory { + currentVersion: SchemaVersion + migrations: SchemaMigration[] + supportedVersions: SchemaVersion[] +} + +export interface VersionedSchema { + version: SchemaVersion + schema: ValidationSchema + metadata: { + createdAt: Date + createdBy: string + description?: string + breakingChanges: string[] + deprecationNotes?: string[] + } +} + +export class SchemaVersionManager { + private versionHistory: SchemaVersionHistory + private schemas: Map + private migrations: Map + + constructor(versionHistory: SchemaVersionHistory) { + this.versionHistory = versionHistory + this.schemas = new Map() + this.migrations = new Map() + this.initializeMigrations() + } + + public getCurrentVersion(): SchemaVersion { + return this.versionHistory.currentVersion + } + + public getSupportedVersions(): SchemaVersion[] { + return [...this.versionHistory.supportedVersions] + } + + public isVersionSupported(version: SchemaVersion): boolean { + const versionKey = this.versionToString(version) + return this.versionHistory.supportedVersions.some((v) => this.versionToString(v) === versionKey) + } + + public isBreakingChange(fromVersion: SchemaVersion, toVersion: SchemaVersion): boolean { + if (fromVersion.major !== toVersion.major) { + return toVersion.major > fromVersion.major + } + + // Check if there's a breaking migration between versions + const migrations = this.getMigrationsBetweenVersions(fromVersion, toVersion) + return migrations.some((m) => m.breaking) + } + + public async migrateData( + data: unknown, + fromVersion: SchemaVersion, + toVersion: SchemaVersion, + ): Promise { + if (this.versionsEqual(fromVersion, toVersion)) { + return data + } + + const migrations = this.getMigrationsBetweenVersions(fromVersion, toVersion) + + if (migrations.length === 0) { + throw new Error(`No migration path found from ${this.versionToString(fromVersion)} to ${this.versionToString(toVersion)}`) + } + + let migratedData = data + + for (const migration of migrations) { + try { + migratedData = await migration.migrationFn(migratedData) + } catch (error) { + throw new Error( + `Migration failed: ${migration.description}. Error: ${error instanceof Error ? error.message : 'Unknown error'}`, + ) + } + } + + return migratedData + } + + public getSchemaForVersion(version: SchemaVersion): VersionedSchema | null { + const versionKey = this.versionToString(version) + return this.schemas.get(versionKey) || null + } + + public registerSchema(schema: VersionedSchema): void { + const versionKey = this.versionToString(schema.version) + this.schemas.set(versionKey, schema) + } + + public addMigration(migration: SchemaMigration): void { + const key = `${this.versionToString(migration.fromVersion)}->${this.versionToString(migration.toVersion)}` + this.migrations.set(key, migration) + } + + public getMigrationsBetweenVersions(fromVersion: SchemaVersion, toVersion: SchemaVersion): SchemaMigration[] { + const migrations: SchemaMigration[] = [] + + // Simple approach: find direct migration path + const key = `${this.versionToString(fromVersion)}->${this.versionToString(toVersion)}` + const directMigration = this.migrations.get(key) + + if (directMigration) { + migrations.push(directMigration) + } else { + // For more complex version paths, we'd need a graph traversal algorithm + // For now, we'll throw an error for unsupported migration paths + throw new Error(`No direct migration path from ${this.versionToString(fromVersion)} to ${this.versionToString(toVersion)}`) + } + + return migrations + } + + public createVersionedSchema( + version: SchemaVersion, + schema: ValidationSchema, + metadata: Omit, + ): VersionedSchema { + return { + version, + schema, + metadata: { + ...metadata, + createdAt: new Date(), + }, + } + } + + public parseVersion(versionString: string): SchemaVersion { + const parts = versionString.split(/[-.]/) + if (parts.length < 3) { + throw new Error('Invalid version string format. Expected: major.minor.patch[-build]') + } + + const major = parseInt(parts[0], 10) + const minor = parseInt(parts[1], 10) + const patch = parseInt(parts[2], 10) + const build = parts[3] || undefined + + if (isNaN(major) || isNaN(minor) || isNaN(patch)) { + throw new Error('Invalid version string: numeric parts required') + } + + return { major, minor, patch, build } + } + + public versionToString(version: SchemaVersion): string { + let versionStr = `${version.major}.${version.minor}.${version.patch}` + if (version.build) { + versionStr += `-${version.build}` + } + return versionStr + } + + public compareVersions(v1: SchemaVersion, v2: SchemaVersion): number { + if (v1.major !== v2.major) { + return v1.major - v2.major + } + if (v1.minor !== v2.minor) { + return v1.minor - v2.minor + } + if (v1.patch !== v2.patch) { + return v1.patch - v2.patch + } + return 0 + } + + public isVersionGreater(v1: SchemaVersion, v2: SchemaVersion): boolean { + return this.compareVersions(v1, v2) > 0 + } + + public isVersionLess(v1: SchemaVersion, v2: SchemaVersion): boolean { + return this.compareVersions(v1, v2) < 0 + } + + public isVersionEqual(v1: SchemaVersion, v2: SchemaVersion): boolean { + return this.compareVersions(v1, v2) === 0 + } + + private versionsEqual(v1: SchemaVersion, v2: SchemaVersion): boolean { + return this.isVersionEqual(v1, v2) + } + + private initializeMigrations(): void { + // Register all migrations + for (const migration of this.versionHistory.migrations) { + this.addMigration(migration) + } + } + + public static create( + versionHistory: SchemaVersionHistory, + ): SchemaVersionManager { + return new SchemaVersionManager(versionHistory) + } + + public static createWithDefaultHistory(): SchemaVersionManager { + const defaultHistory: SchemaVersionHistory = { + currentVersion: { major: 1, minor: 0, patch: 0 }, + supportedVersions: [ + { major: 1, minor: 0, patch: 0 }, + { major: 1, minor: 0, patch: 1 }, + { major: 1, minor: 0, patch: 2 }, + ], + migrations: [], + } + + return new SchemaVersionManager(defaultHistory) + } +} + +// Migration utilities +export class SchemaMigrationUtils { + public static migrateToAddComponentProperty( + componentType: string, + propertyName: string, + defaultValue: unknown, + ): (data: unknown) => unknown { + return (data: unknown) => { + if (typeof data !== 'object' || data === null || Array.isArray(data)) { + return data + } + + const config = data as Record + const components = config.components + + if (!Array.isArray(components)) { + return data + } + + for (const component of components) { + if (typeof component === 'object' && component !== null && !Array.isArray(component)) { + const comp = component as Record + + if (comp.type === componentType) { + if (!comp.props) { + comp.props = {} + } + + if (typeof comp.props === 'object' && !Array.isArray(comp.props)) { + const props = comp.props as Record + if (!(propertyName in props)) { + props[propertyName] = defaultValue + } + } + } + } + } + + return data + } + } + + public static migrateToRenameComponentProperty( + componentType: string, + oldProperty: string, + newProperty: string, + ): (data: unknown) => unknown { + return (data: unknown) => { + if (typeof data !== 'object' || data === null || Array.isArray(data)) { + return data + } + + const config = data as Record + const components = config.components + + if (!Array.isArray(components)) { + return data + } + + for (const component of components) { + if (typeof component === 'object' && component !== null && !Array.isArray(component)) { + const comp = component as Record + + if (comp.type === componentType) { + if (comp.props && typeof comp.props === 'object' && !Array.isArray(comp.props)) { + const props = comp.props as Record + + if (oldProperty in props && !(newProperty in props)) { + props[newProperty] = props[oldProperty] + delete props[oldProperty] + } + } + } + } + } + + return data + } + } + + public static migrateToRemoveComponentProperty( + componentType: string, + propertyName: string, + ): (data: unknown) => unknown { + return (data: unknown) => { + if (typeof data !== 'object' || data === null || Array.isArray(data)) { + return data + } + + const config = data as Record + const components = config.components + + if (!Array.isArray(components)) { + return data + } + + for (const component of components) { + if (typeof component === 'object' && component !== null && !Array.isArray(component)) { + const comp = component as Record + + if (comp.type === componentType) { + if (comp.props && typeof comp.props === 'object' && !Array.isArray(comp.props)) { + const props = comp.props as Record + delete props[propertyName] + } + } + } + } + + return data + } + } + + public static migrateToChangeComponentType( + oldType: string, + newType: string, + propertyMapping?: Record, + ): (data: unknown) => unknown { + return (data: unknown) => { + if (typeof data !== 'object' || data === null || Array.isArray(data)) { + return data + } + + const config = data as Record + const components = config.components + + if (!Array.isArray(components)) { + return data + } + + for (const component of components) { + if (typeof component === 'object' && component !== null && !Array.isArray(component)) { + const comp = component as Record + + if (comp.type === oldType) { + comp.type = newType + + // Map properties if specified + if (propertyMapping && comp.props && typeof comp.props === 'object') { + const props = comp.props as Record + + for (const [oldProp, newProp] of Object.entries(propertyMapping)) { + if (oldProp in props && !(newProp in props)) { + props[newProp] = props[oldProp] + delete props[oldProp] + } + } + } + } + } + } + + return data + } + } + + public static migrateToUpdateScenarioDataStructure( + keyPath: string, + transformation: (value: unknown) => unknown, + ): (data: unknown) => unknown { + return (data: unknown) => { + if (typeof data !== 'object' || data === null || Array.isArray(data)) { + return data + } + + const config = data as Record + + if (config.scenarioData && typeof config.scenarioData === 'object' && !Array.isArray(config.scenarioData)) { + const scenarioData = config.scenarioData as Record + + if (keyPath in scenarioData) { + scenarioData[keyPath] = transformation(scenarioData[keyPath]) + } + } + + return data + } + } +} + +// Example version history for the validation system +export const createDefaultVersionHistory = (): SchemaVersionHistory => ({ + currentVersion: { major: 1, minor: 0, patch: 0 }, + supportedVersions: [ + { major: 1, minor: 0, patch: 0 }, + ], + migrations: [ + { + fromVersion: { major: 1, minor: 0, patch: 0 }, + toVersion: { major: 1, minor: 0, patch: 1 }, + description: 'Add support for new component properties', + breaking: false, + migrationFn: SchemaMigrationUtils.migrateToAddComponentProperty('Button', 'variant', 'primary'), + }, + { + fromVersion: { major: 1, minor: 0, patch: 1 }, + toVersion: { major: 1, minor: 0, patch: 2 }, + description: 'Rename component properties for consistency', + breaking: false, + migrationFn: SchemaMigrationUtils.migrateToRenameComponentProperty('Button', 'onClick', 'action'), + }, + ], +}) \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/security-validator.ts b/packages/domain/src/schema-management/schema-validation/security-validator.ts new file mode 100644 index 0000000..f7dea8d --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/security-validator.ts @@ -0,0 +1,497 @@ +import { SchemaValidationResult, SchemaValidationError, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { CustomValidator } from './validation-engine.js' +import { SchemaValidationSeverity } from '../shared/enums/index.js' + +export interface SecurityConfig { + allowedProtocols: string[] + blockedDomains: string[] + allowedImageDomains: string[] + maxStringLength: number + maxArrayLength: number + maxObjectDepth: number + allowHtml: boolean + allowJavaScript: boolean + allowBase64Data: boolean + requireHttps: boolean + allowedComponentTypes: string[] +} + +export interface SecurityViolation { + type: 'xss' | 'sql_injection' | 'path_traversal' | 'protocol_violation' | 'domain_blocked' | 'data_size' | 'component_type' + message: string + path: string + value: unknown + severity: SchemaValidationSeverity +} + +export class SecurityValidator implements CustomValidator { + private config: SecurityConfig + + constructor(config: SecurityConfig = {}) { + this.config = { + allowedProtocols: ['https:', 'http:'], + blockedDomains: [], + allowedImageDomains: [], + maxStringLength: 10000, + maxArrayLength: 1000, + maxObjectDepth: 10, + allowHtml: false, + allowJavaScript: false, + allowBase64Data: true, + requireHttps: true, + allowedComponentTypes: [ + 'Button', 'Label', 'Text', 'Image', 'List', 'Banner', 'Container', 'Row', 'Column', 'Card', + 'Form', 'Input', 'Select', 'Checkbox', 'Radio', 'Modal', 'Alert', 'Progress', 'Icon' + ], + ...config, + } + } + + public async validate(value: unknown, context?: SchemaValidationContext): Promise { + const violations: SecurityViolation[] = [] + + try { + this.scanValue(value, '$', violations, 0) + + if (violations.length > 0) { + const errors: SchemaValidationError[] = violations.map((violation) => ({ + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'SECURITY_VIOLATION', + message: `${violation.type.toUpperCase()}: ${violation.message}`, + path: violation.path, + severity: violation.severity, + details: { + type: violation.type, + value: violation.value, + }, + timestamp: new Date(), + })) + + return SchemaValidationResult.failure(errors) + } + + return SchemaValidationResult.success(context) + } catch (error) { + return SchemaValidationResult.failure([ + { + id: `security_error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'SECURITY_VALIDATION_ERROR', + message: `Security validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`, + path: context?.path || '$', + severity: SchemaValidationSeverity.ERROR, + timestamp: new Date(), + }, + ]) + } + } + + public validateURL(url: string, context?: SchemaValidationContext): SchemaValidationResult { + try { + const parsedUrl = new URL(url) + const violations: SecurityViolation[] = [] + + // Check protocol + if (!this.config.allowedProtocols.includes(parsedUrl.protocol)) { + violations.push({ + type: 'protocol_violation', + message: `Protocol '${parsedUrl.protocol}' is not allowed`, + path: context?.path || '$', + value: url, + severity: SchemaValidationSeverity.ERROR, + }) + } + + // Require HTTPS if configured + if (this.config.requireHttps && parsedUrl.protocol !== 'https:') { + violations.push({ + type: 'protocol_violation', + message: 'HTTPS is required for security', + path: context?.path || '$', + value: url, + severity: SchemaValidationSeverity.ERROR, + }) + } + + // Check blocked domains + if (this.config.blockedDomains.some((domain) => parsedUrl.hostname.includes(domain))) { + violations.push({ + type: 'domain_blocked', + message: `Domain '${parsedUrl.hostname}' is blocked`, + path: context?.path || '$', + value: url, + severity: SchemaValidationSeverity.ERROR, + }) + } + + if (violations.length > 0) { + const errors: SchemaValidationError[] = violations.map((violation) => ({ + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'SECURITY_VIOLATION', + message: violation.message, + path: violation.path, + severity: violation.severity, + details: violation, + timestamp: new Date(), + })) + + return SchemaValidationResult.failure(errors) + } + + return SchemaValidationResult.success(context) + } catch { + return SchemaValidationResult.failure([ + { + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'INVALID_URL', + message: 'Invalid URL format', + path: context?.path || '$', + severity: SchemaValidationSeverity.ERROR, + timestamp: new Date(), + }, + ]) + } + } + + public validateImageURL(url: string, context?: SchemaValidationContext): SchemaValidationResult { + const baseResult = this.validateURL(url, context) + + if (!baseResult.isValid) { + return baseResult + } + + try { + const parsedUrl = new URL(url) + + // Check if it's an image URL (basic check) + if (!this.isImageUrl(parsedUrl.pathname)) { + return SchemaValidationResult.failure([ + { + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'NOT_AN_IMAGE', + message: 'URL does not point to an image file', + path: context?.path || '$', + severity: SchemaValidationSeverity.WARNING, + timestamp: new Date(), + }, + ]) + } + + // Check allowed image domains + if (this.config.allowedImageDomains.length > 0) { + const isAllowed = this.config.allowedImageDomains.some((domain) => + parsedUrl.hostname.includes(domain), + ) + + if (!isAllowed) { + return SchemaValidationResult.failure([ + { + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'IMAGE_DOMAIN_NOT_ALLOWED', + message: `Image domain '${parsedUrl.hostname}' is not in the allowed list`, + path: context?.path || '$', + severity: SchemaValidationSeverity.ERROR, + timestamp: new Date(), + }, + ]) + } + } + + return SchemaValidationResult.success(context) + } catch { + return SchemaValidationResult.failure([ + { + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'INVALID_IMAGE_URL', + message: 'Invalid image URL', + path: context?.path || '$', + severity: SchemaValidationSeverity.ERROR, + timestamp: new Date(), + }, + ]) + } + } + + public sanitizeInput(input: string): string { + let sanitized = input + + // Remove potentially dangerous patterns + if (!this.config.allowHtml) { + sanitized = sanitized.replace(/<[^>]*>/g, '') + } + + if (!this.config.allowJavaScript) { + sanitized = sanitized + .replace(/javascript:/gi, '') + .replace(/on\w+\s*=/gi, '') + .replace(/]*>.*?<\/script>/gi, '') + .replace(/vbscript:/gi, '') + } + + // Limit length + if (sanitized.length > this.config.maxStringLength) { + sanitized = sanitized.substring(0, this.config.maxStringLength) + } + + return sanitized.trim() + } + + public validateComponentType(componentType: string, context?: SchemaValidationContext): SchemaValidationResult { + if (this.config.allowedComponentTypes.includes(componentType)) { + return SchemaValidationResult.success(context) + } + + return SchemaValidationResult.failure([ + { + id: `security_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'COMPONENT_TYPE_NOT_ALLOWED', + message: `Component type '${componentType}' is not allowed`, + path: context?.path || '$', + severity: SchemaValidationSeverity.ERROR, + details: { + componentType, + allowedTypes: this.config.allowedComponentTypes, + }, + timestamp: new Date(), + }, + ]) + } + + public updateConfig(config: Partial): void { + this.config = { ...this.config, ...config } + } + + public getConfig(): SecurityConfig { + return { ...this.config } + } + + private scanValue(value: unknown, path: string, violations: SecurityViolation[], depth: number): void { + if (depth > this.config.maxObjectDepth) { + violations.push({ + type: 'data_size', + message: 'Maximum object depth exceeded', + path, + value, + severity: SchemaValidationSeverity.ERROR, + }) + return + } + + if (typeof value === 'string') { + this.scanString(value, path, violations) + } else if (Array.isArray(value)) { + this.scanArray(value, path, violations, depth) + } else if (typeof value === 'object' && value !== null) { + this.scanObject(value, path, violations, depth) + } + } + + private scanString(value: string, path: string, violations: SecurityViolation[]): void { + // Check for XSS patterns + const xssPatterns = [ + /]*>.*?<\/script>/gi, + /javascript:/gi, + /vbscript:/gi, + /on\w+\s*=/gi, + /]*>.*?<\/iframe>/gi, + /]*>.*?<\/object>/gi, + /]*>.*?<\/embed>/gi, + ] + + if (!this.config.allowJavaScript) { + for (const pattern of xssPatterns) { + if (pattern.test(value)) { + violations.push({ + type: 'xss', + message: 'Potential XSS attack detected', + path, + value, + severity: SchemaValidationSeverity.ERROR, + }) + break + } + } + } + + // Check for SQL injection patterns + const sqlPatterns = [ + /(\bselect\b|\binsert\b|\bupdate\b|\bdelete\b|\bdrop\b|\bunion\b|\bscript\b)/gi, + /(--|#|\/\*|\*\/)/g, + /(\bor\s+\d+\s*=\s*\d+|\band\s+\d+\s*=\s*\d+)/gi, + ] + + for (const pattern of sqlPatterns) { + if (pattern.test(value)) { + violations.push({ + type: 'sql_injection', + message: 'Potential SQL injection detected', + path, + value, + severity: SchemaValidationSeverity.WARNING, + }) + break + } + } + + // Check for path traversal + const pathTraversalPatterns = [ + /\.\./g, + /%2e%2e/gi, + /%c0%ae%c0%ae/gi, + ] + + for (const pattern of pathTraversalPatterns) { + if (pattern.test(value)) { + violations.push({ + type: 'path_traversal', + message: 'Potential path traversal attack detected', + path, + value, + severity: SchemaValidationSeverity.ERROR, + }) + break + } + } + + // Check string length + if (value.length > this.config.maxStringLength) { + violations.push({ + type: 'data_size', + message: `String length (${value.length}) exceeds maximum allowed (${this.config.maxStringLength})`, + path, + value, + severity: SchemaValidationSeverity.WARNING, + }) + } + + // Check for Base64 encoded content (if not allowed) + if (!this.config.allowBase64Data && this.isBase64(value)) { + violations.push({ + type: 'data_size', + message: 'Base64 encoded content not allowed', + path, + value, + severity: SchemaValidationSeverity.WARNING, + }) + } + } + + private scanArray(value: unknown[], path: string, violations: SecurityViolation[], depth: number): void { + if (value.length > this.config.maxArrayLength) { + violations.push({ + type: 'data_size', + message: `Array length (${value.length}) exceeds maximum allowed (${this.config.maxArrayLength})`, + path, + value, + severity: SchemaValidationSeverity.WARNING, + }) + } + + for (let i = 0; i < Math.min(value.length, this.config.maxArrayLength); i++) { + this.scanValue(value[i], `${path}[${i}]`, violations, depth + 1) + } + } + + private scanObject(value: Record, path: string, violations: SecurityViolation[], depth: number): void { + for (const [key, val] of Object.entries(value)) { + // Check for suspicious key names + if (this.isSuspiciousKey(key)) { + violations.push({ + type: 'xss', + message: `Suspicious key name: ${key}`, + path: `${path}.${key}`, + value: val, + severity: SchemaValidationSeverity.WARNING, + }) + } + + this.scanValue(val, `${path}.${key}`, violations, depth + 1) + } + } + + private isBase64(str: string): boolean { + try { + return btoa(atob(str)) === str + } catch { + return false + } + } + + private isImageUrl(url: string): boolean { + const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.bmp', '.ico'] + return imageExtensions.some((ext) => url.toLowerCase().includes(ext)) + } + + private isSuspiciousKey(key: string): boolean { + const suspiciousKeys = [ + 'onerror', + 'onload', + 'onclick', + 'onmouseover', + 'onmouseout', + 'onkeydown', + 'onkeyup', + 'onkeypress', + 'onchange', + 'onsubmit', + 'onreset', + 'onfocus', + 'onblur', + 'onselect', + 'onscroll', + 'javascript', + 'vbscript', + 'script', + 'eval', + 'function', + 'innerHTML', + 'outerHTML', + ] + + return suspiciousKeys.some((suspicious) => + key.toLowerCase().includes(suspicious.toLowerCase()), + ) + } + + public static create(config?: SecurityConfig): SecurityValidator { + return new SecurityValidator(config) + } + + public static createStrict(): SecurityValidator { + return new SecurityValidator({ + allowedProtocols: ['https:'], + blockedDomains: ['localhost', '127.0.0.1', '0.0.0.0'], + allowedImageDomains: [], + maxStringLength: 5000, + maxArrayLength: 100, + maxObjectDepth: 5, + allowHtml: false, + allowJavaScript: false, + allowBase64Data: false, + requireHttps: true, + allowedComponentTypes: [ + 'Button', 'Label', 'Text', 'Image', 'List', 'Banner', 'Container', 'Row', 'Column', 'Card', + 'Form', 'Input', 'Select', 'Checkbox', 'Radio', 'Modal', 'Alert', 'Progress', 'Icon' + ], + }) + } + + public static createLenient(): SecurityValidator { + return new SecurityValidator({ + allowedProtocols: ['https:', 'http:'], + blockedDomains: [], + allowedImageDomains: [], + maxStringLength: 20000, + maxArrayLength: 5000, + maxObjectDepth: 20, + allowHtml: true, + allowJavaScript: false, + allowBase64Data: true, + requireHttps: false, + allowedComponentTypes: [ + 'Button', 'Label', 'Text', 'Image', 'List', 'Banner', 'Container', 'Row', 'Column', 'Card', + 'Form', 'Input', 'Select', 'Checkbox', 'Radio', 'Modal', 'Alert', 'Progress', 'Icon', + 'Custom' + ], + }) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/store-integration.ts b/packages/domain/src/schema-management/schema-validation/store-integration.ts new file mode 100644 index 0000000..03965cd --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/store-integration.ts @@ -0,0 +1,423 @@ +import { SchemaValidationResult, SchemaValidationError, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { ValidationService, ValidationRequest } from './validation.service.js' +import { SchemaValidationSeverity } from '../shared/enums/index.js' +import { DataTypeCategory } from '../schema-definition/value-objects/data-type.value-object.js' + +export interface StoreValidationRule { + kind: DataTypeCategory + required: boolean + defaultValue?: unknown + min?: number + max?: number + pattern?: string +} + +export interface StoreValidationOptions { + mode: 'strict' | 'lenient' + schema: Record +} + +export interface StoreValue { + type: 'string' | 'number' | 'integer' | 'boolean' | 'color' | 'url' | 'array' | 'object' | 'null' + value: unknown +} + +export interface StorePatch { + op: 'set' | 'remove' | 'merge' + keyPath: string + oldValue?: StoreValue + newValue?: StoreValue +} + +export interface StoreChange { + scenarioID: string + patches: StorePatch[] + transactionID?: string +} + +export class StoreValidationAdapter { + private validationService: ValidationService + private options: StoreValidationOptions + + constructor(validationService: ValidationService, options: StoreValidationOptions) { + this.validationService = validationService + this.options = options + } + + public validateWrite(keyPath: string, value: StoreValue): { isValid: boolean; reason?: string } { + const rule = this.options.schema[keyPath] + if (!rule) { + // No validation rule defined, allow any value + return { isValid: true } + } + + const validationContext: SchemaValidationContext = { + path: keyPath, + timestamp: new Date(), + validator: 'StoreValidationAdapter', + } + + // Convert StoreValue to validation format + const validationValue = this.storeValueToValidationValue(value) + + // Create a temporary schema for this specific validation + const tempSchema = this.createSchemaForRule(keyPath, rule) + + const result = this.validationService.validateWithSchema(validationValue, tempSchema, validationContext) + + if (result.isValid) { + return { isValid: true } + } + + const errorMessage = result.errors[0]?.message || 'Validation failed' + return { isValid: false, reason: errorMessage } + } + + public validateWriteLenient(keyPath: string, value: StoreValue): StoreValue { + const rule = this.options.schema[keyPath] + if (!rule) { + return value + } + + const validationContext: SchemaValidationContext = { + path: keyPath, + timestamp: new Date(), + validator: 'StoreValidationAdapter', + } + + const validationValue = this.storeValueToValidationValue(value) + const tempSchema = this.createSchemaForRule(keyPath, rule) + + const result = this.validationService.validateWithSchema(validationValue, tempSchema, validationContext) + + if (result.isValid) { + return value + } + + // In lenient mode, try to coerce or use default value + if (this.options.mode === 'lenient') { + // Try to coerce the value + const coercedValue = this.coerceValue(validationValue, rule) + if (coercedValue !== undefined) { + return this.validationValueToStoreValue(coercedValue) + } + + // Use default value if available + if (rule.defaultValue !== undefined) { + return this.validationValueToStoreValue(rule.defaultValue) + } + + // Return original value with a warning logged + console.warn(`Validation failed for ${keyPath}: ${result.errors[0]?.message || 'Unknown error'}`) + } + + return value + } + + public validateScenarioData(scenarioData: Record): SchemaValidationResult { + const context: SchemaValidationContext = { + timestamp: new Date(), + validator: 'StoreValidationAdapter', + } + + // Create a schema for the entire scenario data + const scenarioSchema = this.createScenarioDataSchema(scenarioData) + + const result = this.validationService.validateWithSchema(scenarioData, scenarioSchema, context) + + return result + } + + public validatePatch(patch: StorePatch): { isValid: boolean; reason?: string } { + const rule = this.options.schema[patch.keyPath] + + if (!rule) { + return { isValid: true } + } + + if (!patch.newValue) { + return { isValid: true } // Remove operation doesn't need validation + } + + return this.validateWrite(patch.keyPath, patch.newValue) + } + + public validateChange(change: StoreChange): SchemaValidationResult { + const context: SchemaValidationContext = { + timestamp: new Date(), + validator: 'StoreValidationAdapter', + } + + let result = SchemaValidationResult.success(context) + + for (const patch of change.patches) { + const patchValidation = this.validatePatch(patch) + + if (!patchValidation.isValid) { + result = SchemaValidationResult.failure([ + { + id: `patch_error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, + code: 'PATCH_VALIDATION_ERROR', + message: patchValidation.reason || 'Patch validation failed', + path: patch.keyPath, + severity: SchemaValidationSeverity.ERROR, + details: { patch }, + timestamp: new Date(), + }, + ]) + } + } + + return result + } + + public createValidationSchema(scenarioData: Record): any { + const schema: Record = {} + + for (const [keyPath, storeValue] of Object.entries(scenarioData)) { + const rule = this.options.schema[keyPath] + if (rule) { + schema[keyPath] = this.createSchemaForRule(keyPath, rule) + } else { + // Create a schema based on the actual value type + schema[keyPath] = this.createSchemaFromStoreValue(storeValue) + } + } + + return { + type: 'object', + properties: schema, + additionalProperties: false, + } + } + + public mergeValidationOptions(newOptions: StoreValidationOptions): StoreValidationOptions { + return { + mode: newOptions.mode, + schema: { + ...this.options.schema, + ...newOptions.schema, + }, + } + } + + public getValidationOptions(): StoreValidationOptions { + return { ...this.options } + } + + public updateValidationOptions(options: StoreValidationOptions): void { + this.options = options + } + + private storeValueToValidationValue(storeValue: StoreValue): unknown { + switch (storeValue.type) { + case 'string': + return storeValue.value + case 'number': + case 'integer': + return Number(storeValue.value) + case 'boolean': + return Boolean(storeValue.value) + case 'color': + return storeValue.value // Color is already a string + case 'url': + return storeValue.value // URL is already a string + case 'array': + if (Array.isArray(storeValue.value)) { + return storeValue.value.map((item) => { + if (typeof item === 'object' && item !== null && 'type' in item && 'value' in item) { + return this.storeValueToValidationValue(item as StoreValue) + } + return item + }) + } + return [] + case 'object': + if (typeof storeValue.value === 'object' && storeValue.value !== null && !Array.isArray(storeValue.value)) { + const result: Record = {} + for (const [key, value] of Object.entries(storeValue.value)) { + if (typeof value === 'object' && value !== null && 'type' in value && 'value' in value) { + result[key] = this.storeValueToValidationValue(value as StoreValue) + } else { + result[key] = value + } + } + return result + } + return {} + case 'null': + return null + default: + return storeValue.value + } + } + + private validationValueToStoreValue(value: unknown): StoreValue { + if (value === null) { + return { type: 'null', value: null } + } + + switch (typeof value) { + case 'string': + // Check if it's a color (hex format) + if (/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/.test(value)) { + return { type: 'color', value } + } + // Check if it's a URL + try { + new URL(value) + return { type: 'url', value } + } catch { + return { type: 'string', value } + } + case 'number': + return Number.isInteger(value) + ? { type: 'integer', value } + : { type: 'number', value } + case 'boolean': + return { type: 'boolean', value } + case 'object': + if (Array.isArray(value)) { + return { + type: 'array', + value: value.map((item) => this.validationValueToStoreValue(item)), + } + } else { + const obj: Record = {} + for (const [key, val] of Object.entries(value)) { + obj[key] = this.validationValueToStoreValue(val) + } + return { type: 'object', value: obj } + } + default: + return { type: 'string', value: String(value) } + } + } + + private createSchemaForRule(keyPath: string, rule: StoreValidationRule): any { + const baseSchema: any = { + type: this.getJsonSchemaType(rule.kind), + } + + if (rule.required) { + // This would be handled at a higher level in the schema + } + + if (rule.min !== undefined) { + if (rule.kind === DataTypeCategory.STRING) { + baseSchema.minLength = rule.min + } else { + baseSchema.minimum = rule.min + } + } + + if (rule.max !== undefined) { + if (rule.kind === DataTypeCategory.STRING) { + baseSchema.maxLength = rule.max + } else { + baseSchema.maximum = rule.max + } + } + + if (rule.pattern) { + baseSchema.pattern = rule.pattern + } + + return baseSchema + } + + private createSchemaFromStoreValue(storeValue: StoreValue): any { + const baseSchema: any = { + type: this.getJsonSchemaType(storeValue.type), + } + + // Add specific constraints based on the value + switch (storeValue.type) { + case 'color': + baseSchema.pattern = '^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$' + break + case 'url': + baseSchema.format = 'uri' + break + case 'array': + baseSchema.items = { type: 'unknown' } // Could be refined further + break + case 'object': + baseSchema.additionalProperties = true + break + } + + return baseSchema + } + + private createScenarioDataSchema(scenarioData: Record): any { + const properties: Record = {} + + for (const [key, value] of Object.entries(scenarioData)) { + properties[key] = this.createSchemaFromStoreValue(value) + } + + return { + type: 'object', + properties, + additionalProperties: false, + } + } + + private getJsonSchemaType(kind: DataTypeCategory | string): string { + switch (kind) { + case DataTypeCategory.STRING: + case 'color': + case 'url': + return 'string' + case DataTypeCategory.NUMBER: + case DataTypeCategory.FLOAT: + return 'number' + case DataTypeCategory.INTEGER: + return 'integer' + case DataTypeCategory.BOOLEAN: + return 'boolean' + case DataTypeCategory.ARRAY: + return 'array' + case DataTypeCategory.OBJECT: + return 'object' + case 'null': + return 'null' + default: + return 'string' + } + } + + private coerceValue(value: unknown, rule: StoreValidationRule): unknown { + if (value === null || value === undefined) { + return rule.defaultValue + } + + switch (rule.kind) { + case DataTypeCategory.STRING: + return String(value) + case DataTypeCategory.NUMBER: + case DataTypeCategory.FLOAT: + const num = Number(value) + return Number.isNaN(num) ? rule.defaultValue : num + case DataTypeCategory.INTEGER: + const int = Math.floor(Number(value)) + return Number.isNaN(int) ? rule.defaultValue : int + case DataTypeCategory.BOOLEAN: + if (typeof value === 'boolean') return value + if (typeof value === 'string') { + const lower = value.toLowerCase() + if (lower === 'true' || lower === '1' || lower === 'yes') return true + if (lower === 'false' || lower === '0' || lower === 'no') return false + } + if (typeof value === 'number') return value !== 0 + return rule.defaultValue + default: + return value + } + } + + public static create(validationService: ValidationService, options: StoreValidationOptions): StoreValidationAdapter { + return new StoreValidationAdapter(validationService, options) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/validation-engine.ts b/packages/domain/src/schema-management/schema-validation/validation-engine.ts new file mode 100644 index 0000000..2ad96b6 --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/validation-engine.ts @@ -0,0 +1,771 @@ +import { SchemaValidationResult, SchemaValidationError, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { SchemaValidationRule, SchemaValidationRuleType } from '../schema-definition/value-objects/validation-rule.value-object.js' +import { DataType, DataTypeCategory } from '../schema-definition/value-objects/data-type.value-object.js' + +export interface ValidationOptions { + strict?: boolean + context?: SchemaValidationContext + customValidators?: Map + maxDepth?: number + maxErrors?: number +} + +export interface CustomValidator { + validate(value: unknown, context?: SchemaValidationContext): Promise | SchemaValidationResult +} + +export interface SchemaNode { + type: string + required?: string[] + properties?: Record + items?: SchemaNode + enum?: unknown[] + const?: unknown + minLength?: number + maxLength?: number + minimum?: number + maximum?: number + pattern?: string + format?: string + allOf?: SchemaNode[] + anyOf?: SchemaNode[] + oneOf?: SchemaNode[] + not?: SchemaNode + $ref?: string + definitions?: Record + [key: string]: unknown +} + +export interface ValidationSchema { + $schema?: string + $id?: string + type: string + required?: string[] + properties?: Record + items?: SchemaNode + enum?: unknown[] + const?: unknown + minLength?: number + maxLength?: number + minimum?: number + maximum?: number + pattern?: string + format?: string + allOf?: SchemaNode[] + anyOf?: SchemaNode[] + oneOf?: SchemaNode[] + not?: SchemaNode + $ref?: string + definitions?: Record + [key: string]: unknown +} + +export class ValidationEngine { + private schema: ValidationSchema + private customValidators: Map + private maxDepth: number + private maxErrors: number + private currentDepth: number = 0 + private errorCount: number = 0 + + constructor(schema: ValidationSchema, options: ValidationOptions = {}) { + this.schema = schema + this.customValidators = options.customValidators || new Map() + this.maxDepth = options.maxDepth || 10 + this.maxErrors = options.maxErrors || 100 + this.currentDepth = 0 + this.errorCount = 0 + } + + public async validate(data: unknown, context?: SchemaValidationContext): Promise { + this.currentDepth = 0 + this.errorCount = 0 + + const startTime = Date.now() + const result = await this.validateNode(data, this.schema, context || { timestamp: new Date() }) + + const duration = Date.now() - startTime + const metadata = { + timestamp: new Date(), + validator: 'ValidationEngine', + version: '1.0.0', + duration, + } + + return new SchemaValidationResult({ + ...result.value, + metadata, + }) + } + + private async validateNode( + data: unknown, + schema: SchemaNode, + context: SchemaValidationContext, + path: string = '$', + ): Promise { + if (this.currentDepth > this.maxDepth) { + return SchemaValidationResult.failure([ + this.createError('Maximum validation depth exceeded', path, context), + ]) + } + + if (this.errorCount >= this.maxErrors) { + return SchemaValidationResult.failure([ + this.createError('Maximum error count exceeded', path, context), + ]) + } + + this.currentDepth++ + + try { + let result = SchemaValidationResult.success(context) + + // Handle $ref + if (schema.$ref) { + const resolvedSchema = this.resolveRef(schema.$ref, schema) + if (resolvedSchema) { + result = await this.validateNode(data, resolvedSchema, context, path) + } else { + result = SchemaValidationResult.failure([ + this.createError(`Unable to resolve reference: ${schema.$ref}`, path, context), + ]) + } + } + // Handle type validation + else if (schema.type) { + result = this.validateType(data, schema, context, path) + } + // Handle enum validation + else if (schema.enum) { + result = this.validateEnum(data, schema, context, path) + } + // Handle const validation + else if (schema.const !== undefined) { + result = this.validateConst(data, schema, context, path) + } + // Handle combined schemas + else if (schema.allOf || schema.anyOf || schema.oneOf) { + result = await this.validateCombinedSchemas(data, schema, context, path) + } else { + // Default: accept any value + result = SchemaValidationResult.success(context) + } + + // Handle additional validations + if (result.isValid) { + result = this.applyAdditionalValidations(data, schema, context, path, result) + } + + return result + } finally { + this.currentDepth-- + } + } + + private validateType( + data: unknown, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + ): SchemaValidationResult { + const expectedType = schema.type + let isValid = false + + switch (expectedType) { + case 'null': + isValid = data === null + break + case 'boolean': + isValid = typeof data === 'boolean' + break + case 'number': + case 'integer': + isValid = typeof data === 'number' && !Number.isNaN(data) + if (isValid && expectedType === 'integer') { + isValid = Number.isInteger(data) + } + break + case 'string': + isValid = typeof data === 'string' + break + case 'array': + isValid = Array.isArray(data) + break + case 'object': + isValid = typeof data === 'object' && data !== null && !Array.isArray(data) + break + default: + isValid = true // Unknown types are considered valid + } + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError( + `Expected type ${expectedType}, got ${this.getTypeName(data)}`, + path, + context, + { expected: expectedType, received: this.getTypeName(data) }, + ), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateEnum( + data: unknown, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + ): SchemaValidationResult { + if (!schema.enum || !Array.isArray(schema.enum)) { + return SchemaValidationResult.success(context) + } + + const isValid = schema.enum.includes(data) + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError( + `Value must be one of: ${schema.enum.map((v) => JSON.stringify(v)).join(', ')}`, + path, + context, + { expected: schema.enum, received: data }, + ), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateConst( + data: unknown, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + ): SchemaValidationResult { + if (schema.const === undefined) { + return SchemaValidationResult.success(context) + } + + const isValid = this.deepEqual(data, schema.const) + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError( + `Value must be ${JSON.stringify(schema.const)}`, + path, + context, + { expected: schema.const, received: data }, + ), + ]) + } + + return SchemaValidationResult.success(context) + } + + private async validateCombinedSchemas( + data: unknown, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + ): Promise { + let result = SchemaValidationResult.success(context) + + // allOf: all schemas must be valid + if (schema.allOf) { + for (let i = 0; i < schema.allOf.length; i++) { + const subResult = await this.validateNode(data, schema.allOf[i], context, `${path}/allOf[${i}]`) + result = result.merge(subResult) + + if (!subResult.isValid) { + // For allOf, we continue validating all schemas even if one fails + } + } + } + + // anyOf: at least one schema must be valid + if (schema.anyOf) { + let anyValid = false + const anyOfErrors: SchemaValidationError[] = [] + + for (let i = 0; i < schema.anyOf.length; i++) { + const subResult = await this.validateNode(data, schema.anyOf[i], context, `${path}/anyOf[${i}]`) + + if (subResult.isValid) { + anyValid = true + break + } else { + anyOfErrors.push(...subResult.errors) + } + } + + if (!anyValid) { + return SchemaValidationResult.failure([ + this.createError('Value must match at least one of the anyOf schemas', path, context, { + errors: anyOfErrors, + }), + ]) + } + } + + // oneOf: exactly one schema must be valid + if (schema.oneOf) { + let validCount = 0 + const oneOfErrors: SchemaValidationError[] = [] + + for (let i = 0; i < schema.oneOf.length; i++) { + const subResult = await this.validateNode(data, schema.oneOf[i], context, `${path}/oneOf[${i}]`) + + if (subResult.isValid) { + validCount++ + if (validCount > 1) { + return SchemaValidationResult.failure([ + this.createError('Value must match exactly one of the oneOf schemas', path, context), + ]) + } + } else { + oneOfErrors.push(...subResult.errors) + } + } + + if (validCount === 0) { + return SchemaValidationResult.failure([ + this.createError('Value must match one of the oneOf schemas', path, context, { + errors: oneOfErrors, + }), + ]) + } + } + + return result + } + + private applyAdditionalValidations( + data: unknown, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + baseResult: SchemaValidationResult, + ): SchemaValidationResult { + let result = baseResult + + // String validations + if (typeof data === 'string') { + result = this.validateStringConstraints(data, schema, context, path, result) + } + + // Number validations + if (typeof data === 'number') { + result = this.validateNumberConstraints(data, schema, context, path, result) + } + + // Array validations + if (Array.isArray(data)) { + result = this.validateArrayConstraints(data, schema, context, path, result) + } + + // Object validations + if (typeof data === 'object' && data !== null && !Array.isArray(data)) { + result = this.validateObjectConstraints(data as Record, schema, context, path, result) + } + + return result + } + + private validateStringConstraints( + data: string, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + result: SchemaValidationResult, + ): SchemaValidationResult { + let currentResult = result + + // minLength + if (schema.minLength !== undefined && data.length < schema.minLength) { + currentResult = SchemaValidationResult.failure([ + this.createError( + `String length must be at least ${schema.minLength}`, + path, + context, + { expected: schema.minLength, received: data.length }, + ), + ]) + } + + // maxLength + if (schema.maxLength !== undefined && data.length > schema.maxLength) { + currentResult = SchemaValidationResult.failure([ + this.createError( + `String length must be at most ${schema.maxLength}`, + path, + context, + { expected: schema.maxLength, received: data.length }, + ), + ]) + } + + // pattern + if (schema.pattern && !new RegExp(schema.pattern).test(data)) { + currentResult = SchemaValidationResult.failure([ + this.createError(`String does not match pattern: ${schema.pattern}`, path, context, { + pattern: schema.pattern, + }), + ]) + } + + // format + if (schema.format) { + const formatResult = this.validateFormat(data, schema.format, context, path) + if (!formatResult.isValid) { + currentResult = formatResult + } + } + + return currentResult + } + + private validateNumberConstraints( + data: number, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + result: SchemaValidationResult, + ): SchemaValidationResult { + let currentResult = result + + // minimum + if (schema.minimum !== undefined && data < schema.minimum) { + currentResult = SchemaValidationResult.failure([ + this.createError( + `Number must be at least ${schema.minimum}`, + path, + context, + { expected: schema.minimum, received: data }, + ), + ]) + } + + // maximum + if (schema.maximum !== undefined && data > schema.maximum) { + currentResult = SchemaValidationResult.failure([ + this.createError( + `Number must be at most ${schema.maximum}`, + path, + context, + { expected: schema.maximum, received: data }, + ), + ]) + } + + return currentResult + } + + private validateArrayConstraints( + data: unknown[], + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + result: SchemaValidationResult, + ): SchemaValidationResult { + let currentResult = result + + // minItems + if (schema.minItems !== undefined && data.length < schema.minItems) { + currentResult = SchemaValidationResult.failure([ + this.createError( + `Array must have at least ${schema.minItems} items`, + path, + context, + { expected: schema.minItems, received: data.length }, + ), + ]) + } + + // maxItems + if (schema.maxItems !== undefined && data.length > schema.maxItems) { + currentResult = SchemaValidationResult.failure([ + this.createError( + `Array must have at most ${schema.maxItems} items`, + path, + context, + { expected: schema.maxItems, received: data.length }, + ), + ]) + } + + // items validation + if (schema.items) { + for (let i = 0; i < data.length; i++) { + const itemResult = this.validateNode(data[i], schema.items, context, `${path}[${i}]`) + if (!itemResult.isValid) { + currentResult = currentResult.merge(itemResult) + } + } + } + + return currentResult + } + + private validateObjectConstraints( + data: Record, + schema: SchemaNode, + context: SchemaValidationContext, + path: string, + result: SchemaValidationResult, + ): SchemaValidationResult { + let currentResult = result + + // required properties + if (schema.required && Array.isArray(schema.required)) { + for (const prop of schema.required) { + if (!(prop in data)) { + currentResult = SchemaValidationResult.failure([ + this.createError(`Missing required property: ${prop}`, `${path}.${prop}`, context), + ]) + } + } + } + + // properties validation + if (schema.properties) { + for (const [prop, propSchema] of Object.entries(schema.properties)) { + if (prop in data) { + const propResult = this.validateNode(data[prop], propSchema, context, `${path}.${prop}`) + if (!propResult.isValid) { + currentResult = currentResult.merge(propResult) + } + } + } + } + + // additional properties + if (schema.additionalProperties === false) { + if (schema.properties) { + const allowedProps = Object.keys(schema.properties) + const extraProps = Object.keys(data).filter((prop) => !allowedProps.includes(prop)) + for (const prop of extraProps) { + currentResult = SchemaValidationResult.failure([ + this.createError(`Additional property not allowed: ${prop}`, `${path}.${prop}`, context), + ]) + } + } + } + + return currentResult + } + + private validateFormat( + data: string, + format: string, + context: SchemaValidationContext, + path: string, + ): SchemaValidationResult { + switch (format) { + case 'date-time': + return this.validateDateTime(data, path, context) + case 'email': + return this.validateEmail(data, path, context) + case 'hostname': + return this.validateHostname(data, path, context) + case 'ipv4': + return this.validateIPv4(data, path, context) + case 'ipv6': + return this.validateIPv6(data, path, context) + case 'uri': + return this.validateURI(data, path, context) + case 'uuid': + return this.validateUUID(data, path, context) + default: + return SchemaValidationResult.success(context) + } + } + + private validateDateTime( + data: string, + path: string, + context: SchemaValidationContext, + ): SchemaValidationResult { + const date = new Date(data) + const isValid = !Number.isNaN(date.getTime()) && data === date.toISOString() + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError('Invalid date-time format', path, context, { + received: data, + expected: 'ISO 8601 date-time format', + }), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateEmail(data: string, path: string, context: SchemaValidationContext): SchemaValidationResult { + const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/ + const isValid = emailRegex.test(data) + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError('Invalid email format', path, context, { + received: data, + }), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateHostname( + data: string, + path: string, + context: SchemaValidationContext, + ): SchemaValidationResult { + const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/ + const isValid = hostnameRegex.test(data) && data.length <= 253 + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError('Invalid hostname format', path, context, { + received: data, + }), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateIPv4(data: string, path: string, context: SchemaValidationContext): SchemaValidationResult { + const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/ + const isValid = ipv4Regex.test(data) + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError('Invalid IPv4 format', path, context, { + received: data, + }), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateIPv6(data: string, path: string, context: SchemaValidationContext): SchemaValidationResult { + const ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::1$|^::$/ + const isValid = ipv6Regex.test(data) + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError('Invalid IPv6 format', path, context, { + received: data, + }), + ]) + } + + return SchemaValidationResult.success(context) + } + + private validateURI(data: string, path: string, context: SchemaValidationContext): SchemaValidationResult { + try { + new URL(data) + return SchemaValidationResult.success(context) + } catch { + return SchemaValidationResult.failure([ + this.createError('Invalid URI format', path, context, { + received: data, + }), + ]) + } + } + + private validateUUID(data: string, path: string, context: SchemaValidationContext): SchemaValidationResult { + const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i + const isValid = uuidRegex.test(data) + + if (!isValid) { + return SchemaValidationResult.failure([ + this.createError('Invalid UUID format', path, context, { + received: data, + }), + ]) + } + + return SchemaValidationResult.success(context) + } + + private resolveRef(ref: string, schema: SchemaNode): SchemaNode | null { + if (ref.startsWith('#/')) { + const path = ref.substring(2).split('/') + return this.navigateSchema(schema, path) + } + + return null + } + + private navigateSchema(schema: SchemaNode, path: string[]): SchemaNode | null { + let current: SchemaNode = schema + + for (const segment of path) { + if (segment === 'definitions' && current.definitions) { + current = current.definitions as SchemaNode + } else if (current.properties && segment in current.properties) { + current = current.properties[segment] + } else { + return null + } + } + + return current + } + + private createError( + message: string, + path: string, + context: SchemaValidationContext, + details?: Record, + ): SchemaValidationError { + const id = `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}` + + return { + id, + code: 'VALIDATION_ERROR', + message, + path, + severity: 'error' as const, + details, + timestamp: new Date(), + } + } + + private getTypeName(value: unknown): string { + if (value === null) return 'null' + if (Array.isArray(value)) return 'array' + return typeof value + } + + private deepEqual(a: unknown, b: unknown): boolean { + if (a === b) return true + if (a == null || b == null) return a === b + if (typeof a !== typeof b) return false + if (typeof a !== 'object') return a === b + if (Array.isArray(a) !== Array.isArray(b)) return false + + const keysA = Object.keys(a as Record) + const keysB = Object.keys(b as Record) + + if (keysA.length !== keysB.length) return false + + for (const key of keysA) { + if (!keysB.includes(key)) return false + if (!this.deepEqual((a as Record)[key], (b as Record)[key])) return false + } + + return true + } + + public static create(schema: ValidationSchema, options?: ValidationOptions): ValidationEngine { + return new ValidationEngine(schema, options) + } +} \ No newline at end of file diff --git a/packages/domain/src/schema-management/schema-validation/validation.service.ts b/packages/domain/src/schema-management/schema-validation/validation.service.ts new file mode 100644 index 0000000..a79a1a1 --- /dev/null +++ b/packages/domain/src/schema-management/schema-validation/validation.service.ts @@ -0,0 +1,322 @@ +import { readFileSync } from 'fs' +import { resolve } from 'path' +import { SchemaValidationResult, SchemaValidationContext } from './value-objects/validation-result.vo.js' +import { ValidationEngine, ValidationSchema } from './validation-engine.js' +import { CustomValidatorsRegistry } from './custom-validators.js' +import { ErrorFormatter } from './error-formatter.js' +import { SchemaValidationSeverity } from '../shared/enums/index.js' + +export interface ValidationServiceOptions { + schemaPath?: string + customValidators?: Map + strict?: boolean + maxDepth?: number + maxErrors?: number +} + +export interface ValidationRequest { + data: unknown + context?: SchemaValidationContext + options?: { + strict?: boolean + includeWarnings?: boolean + includeInfo?: boolean + customValidators?: string[] + } +} + +export interface BatchValidationRequest { + items: Array<{ + id: string + data: unknown + context?: SchemaValidationContext + }> + options?: ValidationServiceOptions +} + +export interface BatchValidationResult { + total: number + valid: number + invalid: number + results: Array<{ + id: string + result: SchemaValidationResult + }> + summary: { + totalErrors: number + totalWarnings: number + totalInfo: number + averageDuration: number + } +} + +export class ValidationService { + private engine: ValidationEngine + private schema: ValidationSchema + private customValidators: CustomValidatorsRegistry + private errorFormatter: ErrorFormatter + + constructor(options: ValidationServiceOptions = {}) { + this.schema = this.loadSchema(options.schemaPath) + this.customValidators = new CustomValidatorsRegistry() + this.engine = ValidationEngine.create(this.schema, { + customValidators: this.customValidators.getAll(), + maxDepth: options.maxDepth || 10, + maxErrors: options.maxErrors || 100, + }) + this.errorFormatter = ErrorFormatter.create() + } + + public async validate(request: ValidationRequest): Promise { + const context = { + ...request.context, + timestamp: new Date(), + validator: 'ValidationService', + } + + const result = await this.engine.validate(request.data, context) + + // Apply custom validations if specified + if (request.options?.customValidators) { + for (const validatorName of request.options.customValidators) { + const validator = this.customValidators.get(validatorName) + if (validator) { + const customResult = await validator.validate(request.data, context) + result = result.merge(customResult) + } + } + } + + return result + } + + public async validateWithSchema( + data: unknown, + schema: ValidationSchema, + context?: SchemaValidationContext, + ): Promise { + const customEngine = ValidationEngine.create(schema, { + customValidators: this.customValidators.getAll(), + }) + + return customEngine.validate(data, context) + } + + public async batchValidate(request: BatchValidationRequest): Promise { + const startTime = Date.now() + const results: Array<{ id: string; result: SchemaValidationResult }> = [] + let totalErrors = 0 + let totalWarnings = 0 + let totalInfo = 0 + let totalDuration = 0 + + for (const item of request.items) { + const itemStartTime = Date.now() + const result = await this.validate({ + data: item.data, + context: item.context, + options: request.options, + }) + const itemDuration = Date.now() - itemStartTime + + results.push({ + id: item.id, + result: { + ...result, + duration: itemDuration, + }, + }) + + totalErrors += result.errorCount + totalWarnings += result.warningCount + totalInfo += result.infoCount + totalDuration += itemDuration + } + + const valid = results.filter((r) => r.result.isValid).length + const invalid = results.length - valid + const averageDuration = results.length > 0 ? totalDuration / results.length : 0 + const totalTime = Date.now() - startTime + + return { + total: results.length, + valid, + invalid, + results, + summary: { + totalErrors, + totalWarnings, + totalInfo, + averageDuration, + }, + } + } + + public validateSync(request: ValidationRequest): SchemaValidationResult { + // For synchronous validation, we'll use a simplified approach + // In a real implementation, you might want to have a sync version of the engine + const context = { + ...request.context, + timestamp: new Date(), + validator: 'ValidationService', + } + + // This is a simplified sync version - in practice you'd want a proper sync engine + return this.runSyncValidation(request.data, context) + } + + public formatErrors(result: SchemaValidationResult): any { + return this.errorFormatter.formatReport(result) + } + + public formatForAdminUI(result: SchemaValidationResult): any { + return this.errorFormatter.formatForAdminUI(result) + } + + public formatForClient(result: SchemaValidationResult): any { + return this.errorFormatter.formatForClientRuntime(result) + } + + public generateReport(result: SchemaValidationResult): string { + return this.errorFormatter.generateJSONReport(result) + } + + public generateHTMLReport(result: SchemaValidationResult): string { + return this.errorFormatter.generateHTMLReport(result) + } + + public getSchema(): ValidationSchema { + return { ...this.schema } + } + + public updateSchema(schema: ValidationSchema): void { + this.schema = schema + this.engine = ValidationEngine.create(schema, { + customValidators: this.customValidators.getAll(), + }) + } + + public addCustomValidator(name: string, validator: any): void { + this.customValidators.register(name, validator) + this.engine = ValidationEngine.create(this.schema, { + customValidators: this.customValidators.getAll(), + }) + } + + public removeCustomValidator(name: string): void { + // Note: The current architecture doesn't support removing validators from the engine + // You would need to recreate the engine without that validator + } + + public getCustomValidators(): string[] { + return Array.from(this.customValidators.getAll().keys()) + } + + public validateComponentType(componentType: string): boolean { + const allowedTypes = [ + 'Button', 'Label', 'Text', 'Image', 'List', 'Banner', 'Container', 'Row', 'Column', 'Card', + 'Form', 'Input', 'Select', 'Checkbox', 'Radio', 'Modal', 'Alert', 'Progress', 'Icon' + ] + return allowedTypes.includes(componentType) + } + + public validateScenarioDataKey(key: string): boolean { + // Scenario data keys should follow specific patterns + const validKeyPattern = /^[a-zA-Z][a-zA-Z0-9_.]*$/ + return validKeyPattern.test(key) && key.length <= 100 + } + + public sanitizeInput(input: string): string { + // Basic input sanitization + return input + .replace(/)<[^<]*)*<\/script>/gi, '') + .replace(/javascript:/gi, '') + .replace(/on\w+\s*=/gi, '') + .trim() + } + + public validateSecurityConstraints(data: unknown): SchemaValidationResult { + const context: SchemaValidationContext = { + timestamp: new Date(), + validator: 'SecurityValidator', + } + + const securityValidator = this.customValidators.get('security') + if (securityValidator) { + return securityValidator.validate(data, context) as any + } + + return SchemaValidationResult.success(context) + } + + public createValidationContext( + path?: string, + metadata?: Record, + ): SchemaValidationContext { + return { + path, + ...metadata, + timestamp: new Date(), + } + } + + private loadSchema(schemaPath?: string): ValidationSchema { + if (schemaPath) { + try { + const fullPath = resolve(schemaPath) + const schemaContent = readFileSync(fullPath, 'utf-8') + return JSON.parse(schemaContent) + } catch (error) { + console.error('Failed to load schema:', error) + } + } + + // Return the default master schema + const defaultSchemaPath = resolve(__dirname, 'master.schema.json') + try { + const schemaContent = readFileSync(defaultSchemaPath, 'utf-8') + return JSON.parse(schemaContent) + } catch { + // Return a minimal schema if file doesn't exist + return { + type: 'object', + additionalProperties: true, + } + } + } + + private runSyncValidation(data: unknown, context: SchemaValidationContext): SchemaValidationResult { + // Simplified synchronous validation for basic cases + // This is a placeholder - in a real implementation you'd have proper sync validation + + const errors: any[] = [] + + // Basic type validation + if (typeof data !== 'object' || data === null) { + errors.push({ + id: `sync_error_${Date.now()}`, + code: 'INVALID_TYPE', + message: 'Data must be an object', + path: '$', + severity: SchemaValidationSeverity.ERROR, + timestamp: new Date(), + }) + } + + if (errors.length > 0) { + return SchemaValidationResult.failure(errors) + } + + return SchemaValidationResult.success(context) + } + + public static create(options?: ValidationServiceOptions): ValidationService { + return new ValidationService(options) + } + + public static createWithCustomSchema(schema: ValidationSchema, options?: ValidationServiceOptions): ValidationService { + const service = new ValidationService({ ...options, schemaPath: undefined }) + service.updateSchema(schema) + return service + } +} \ No newline at end of file