@sschepis/magazine 0.1.0

package/src/components/ConfigSchema.js

@@ -0,0 +1,506 @@
+/**
+ * ConfigSchema - Configuration schema definition and validation
+ */
+export default class ConfigSchema {
+    constructor() {
+        // Define the configuration schema
+        this.schema = {
+            // Required fields
+            required: ['name', 'address', 'abi', 'provider'],
+            
+            // Field definitions
+            fields: {
+                name: {
+                    type: 'string',
+                    description: 'Name of the magazine',
+                    minLength: 1,
+                    maxLength: 100,
+                    pattern: /^[a-zA-Z0-9\s\-_]+$/,
+                    example: 'My Event Magazine'
+                },
+                
+                address: {
+                    type: 'string',
+                    description: 'Contract address',
+                    pattern: /^0x[a-fA-F0-9]{40}$/,
+                    example: '0x1234567890123456789012345678901234567890'
+                },
+                
+                abi: {
+                    type: 'array',
+                    description: 'Contract ABI',
+                    minItems: 1,
+                    items: {
+                        type: 'object',
+                        required: ['type'],
+                        properties: {
+                            type: {
+                                type: 'string',
+                                enum: ['function', 'event', 'constructor', 'fallback', 'receive']
+                            },
+                            name: { type: 'string' },
+                            inputs: { type: 'array' },
+                            outputs: { type: 'array' },
+                            anonymous: { type: 'boolean' }
+                        }
+                    }
+                },
+                
+                provider: {
+                    type: ['string', 'object'],
+                    description: 'Ethereum provider URL or object',
+                    validate: (value) => {
+                        if (typeof value === 'string') {
+                            return value.startsWith('http://') || 
+                                   value.startsWith('https://') || 
+                                   value.startsWith('ws://') || 
+                                   value.startsWith('wss://');
+                        }
+                        return typeof value === 'object' && value !== null;
+                    },
+                    example: 'http://localhost:8545'
+                },
+                
+                networkId: {
+                    type: 'number',
+                    description: 'Network ID',
+                    optional: true,
+                    min: 1,
+                    example: 1
+                },
+                
+                gun: {
+                    type: 'object',
+                    description: 'Gun.js configuration',
+                    optional: true,
+                    properties: {
+                        peers: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            example: ['http://localhost:8765/gun']
+                        },
+                        file: {
+                            type: 'string',
+                            example: 'radata'
+                        },
+                        localStorage: {
+                            type: 'boolean',
+                            default: true
+                        },
+                        radisk: {
+                            type: 'boolean',
+                            default: true
+                        },
+                        multicast: {
+                            type: ['boolean', 'object'],
+                            default: false
+                        },
+                        compression: {
+                            type: 'object',
+                            properties: {
+                                enabled: {
+                                    type: 'boolean',
+                                    default: true
+                                },
+                                strategy: {
+                                    type: 'string',
+                                    enum: ['none', 'json', 'gzip', 'optimized'],
+                                    default: 'optimized'
+                                }
+                            }
+                        }
+                    }
+                },
+                
+                logLevel: {
+                    type: 'string',
+                    description: 'Logging level',
+                    optional: true,
+                    enum: ['error', 'warn', 'info', 'debug', 'trace'],
+                    default: 'info'
+                },
+                
+                maxRetries: {
+                    type: 'number',
+                    description: 'Maximum retry attempts',
+                    optional: true,
+                    min: 0,
+                    max: 10,
+                    default: 3
+                },
+                
+                retryDelay: {
+                    type: 'number',
+                    description: 'Delay between retries in milliseconds',
+                    optional: true,
+                    min: 100,
+                    max: 60000,
+                    default: 1000
+                },
+                
+                timeout: {
+                    type: 'number',
+                    description: 'Operation timeout in milliseconds',
+                    optional: true,
+                    min: 1000,
+                    max: 300000,
+                    default: 30000
+                },
+                
+                batchSize: {
+                    type: 'number',
+                    description: 'Event sync batch size',
+                    optional: true,
+                    min: 1,
+                    max: 10000,
+                    default: 1000
+                },
+                
+                startBlockNumber: {
+                    type: 'number',
+                    description: 'Starting block number for sync',
+                    optional: true,
+                    min: 0,
+                    default: 1
+                },
+                
+                autoSync: {
+                    type: 'boolean',
+                    description: 'Enable automatic syncing',
+                    optional: true,
+                    default: false
+                },
+                
+                syncInterval: {
+                    type: 'number',
+                    description: 'Auto-sync interval in milliseconds',
+                    optional: true,
+                    min: 10000,
+                    max: 3600000,
+                    default: 60000,
+                    dependsOn: 'autoSync'
+                }
+            }
+        };
+        
+        // Validation error messages
+        this.errorMessages = {
+            required: (field) => `${field} is required`,
+            type: (field, expected, actual) => `${field} must be of type ${expected}, got ${actual}`,
+            minLength: (field, min) => `${field} must be at least ${min} characters long`,
+            maxLength: (field, max) => `${field} must be at most ${max} characters long`,
+            pattern: (field) => `${field} has invalid format`,
+            min: (field, min) => `${field} must be at least ${min}`,
+            max: (field, max) => `${field} must be at most ${max}`,
+            enum: (field, values) => `${field} must be one of: ${values.join(', ')}`,
+            minItems: (field, min) => `${field} must have at least ${min} items`,
+            custom: (field, message) => `${field}: ${message}`
+        };
+    }
+
+    /**
+     * Validate configuration against schema
+     * @param {Object} config - Configuration to validate
+     * @returns {Object} Validation result
+     */
+    validate(config) {
+        const errors = [];
+        const warnings = [];
+        const validated = {};
+        
+        // Check required fields
+        for (const field of this.schema.required) {
+            if (!config.hasOwnProperty(field) || config[field] === undefined || config[field] === null) {
+                errors.push({
+                    field,
+                    type: 'required',
+                    message: this.errorMessages.required(field)
+                });
+            }
+        }
+        
+        // Validate each field
+        for (const [field, definition] of Object.entries(this.schema.fields)) {
+            if (config.hasOwnProperty(field)) {
+                const result = this._validateField(field, config[field], definition);
+                
+                if (result.errors.length > 0) {
+                    errors.push(...result.errors);
+                } else {
+                    validated[field] = result.value;
+                }
+                
+                if (result.warnings.length > 0) {
+                    warnings.push(...result.warnings);
+                }
+            } else if (!definition.optional && !this.schema.required.includes(field)) {
+                // Field is not required but has a default value
+                if (definition.hasOwnProperty('default')) {
+                    validated[field] = definition.default;
+                }
+            }
+        }
+        
+        // Check for unknown fields
+        for (const field of Object.keys(config)) {
+            if (!this.schema.fields.hasOwnProperty(field)) {
+                warnings.push({
+                    field,
+                    type: 'unknown',
+                    message: `Unknown configuration field: ${field}`
+                });
+                // Include unknown fields in validated config
+                validated[field] = config[field];
+            }
+        }
+        
+        // Check field dependencies
+        for (const [field, definition] of Object.entries(this.schema.fields)) {
+            if (definition.dependsOn && validated[field] !== undefined) {
+                if (!validated[definition.dependsOn]) {
+                    warnings.push({
+                        field,
+                        type: 'dependency',
+                        message: `${field} depends on ${definition.dependsOn} being set`
+                    });
+                }
+            }
+        }
+        
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            validated
+        };
+    }
+
+    /**
+     * Validate a single field
+     * @private
+     */
+    _validateField(field, value, definition) {
+        const errors = [];
+        const warnings = [];
+        let validatedValue = value;
+        
+        // Type validation
+        const actualType = Array.isArray(value) ? 'array' : typeof value;
+        const expectedTypes = Array.isArray(definition.type) ? definition.type : [definition.type];
+        
+        if (!expectedTypes.includes(actualType)) {
+            errors.push({
+                field,
+                type: 'type',
+                message: this.errorMessages.type(field, expectedTypes.join(' or '), actualType)
+            });
+            return { errors, warnings, value };
+        }
+        
+        // Apply transformation if defined
+        if (definition.transform && typeof definition.transform === 'function') {
+            validatedValue = definition.transform(validatedValue);
+        }
+        
+        // String validations
+        if (actualType === 'string') {
+            if (definition.minLength && validatedValue.length < definition.minLength) {
+                errors.push({
+                    field,
+                    type: 'minLength',
+                    message: this.errorMessages.minLength(field, definition.minLength)
+                });
+            }
+            
+            if (definition.maxLength && validatedValue.length > definition.maxLength) {
+                errors.push({
+                    field,
+                    type: 'maxLength',
+                    message: this.errorMessages.maxLength(field, definition.maxLength)
+                });
+            }
+            
+            if (definition.pattern && !definition.pattern.test(validatedValue)) {
+                errors.push({
+                    field,
+                    type: 'pattern',
+                    message: this.errorMessages.pattern(field)
+                });
+            }
+            
+            if (definition.enum && !definition.enum.includes(validatedValue)) {
+                errors.push({
+                    field,
+                    type: 'enum',
+                    message: this.errorMessages.enum(field, definition.enum)
+                });
+            }
+        }
+        
+        // Number validations
+        if (actualType === 'number') {
+            if (definition.min !== undefined && validatedValue < definition.min) {
+                errors.push({
+                    field,
+                    type: 'min',
+                    message: this.errorMessages.min(field, definition.min)
+                });
+            }
+            
+            if (definition.max !== undefined && validatedValue > definition.max) {
+                errors.push({
+                    field,
+                    type: 'max',
+                    message: this.errorMessages.max(field, definition.max)
+                });
+            }
+        }
+        
+        // Array validations
+        if (actualType === 'array') {
+            if (definition.minItems && validatedValue.length < definition.minItems) {
+                errors.push({
+                    field,
+                    type: 'minItems',
+                    message: this.errorMessages.minItems(field, definition.minItems)
+                });
+            }
+            
+            // Validate array items if schema is provided
+            if (definition.items) {
+                validatedValue.forEach((item, index) => {
+                    const itemResult = this._validateField(
+                        `${field}[${index}]`,
+                        item,
+                        definition.items
+                    );
+                    errors.push(...itemResult.errors);
+                    warnings.push(...itemResult.warnings);
+                });
+            }
+        }
+        
+        // Object validations
+        if (actualType === 'object' && definition.properties) {
+            for (const [prop, propDef] of Object.entries(definition.properties)) {
+                if (validatedValue.hasOwnProperty(prop)) {
+                    const propResult = this._validateField(
+                        `${field}.${prop}`,
+                        validatedValue[prop],
+                        propDef
+                    );
+                    errors.push(...propResult.errors);
+                    warnings.push(...propResult.warnings);
+                }
+            }
+        }
+        
+        // Custom validation
+        if (definition.validate && typeof definition.validate === 'function') {
+            const isValid = definition.validate(validatedValue);
+            if (!isValid) {
+                errors.push({
+                    field,
+                    type: 'custom',
+                    message: this.errorMessages.custom(field, 'Custom validation failed')
+                });
+            }
+        }
+        
+        return { errors, warnings, value: validatedValue };
+    }
+
+    /**
+     * Get schema documentation
+     * @returns {Object} Schema documentation
+     */
+    getDocumentation() {
+        const docs = {
+            description: 'Magazine configuration schema',
+            required: this.schema.required,
+            fields: {}
+        };
+        
+        for (const [field, definition] of Object.entries(this.schema.fields)) {
+            docs.fields[field] = {
+                type: definition.type,
+                description: definition.description,
+                required: this.schema.required.includes(field),
+                optional: definition.optional,
+                default: definition.default,
+                example: definition.example
+            };
+            
+            if (definition.enum) {
+                docs.fields[field].enum = definition.enum;
+            }
+            
+            if (definition.min !== undefined || definition.max !== undefined) {
+                docs.fields[field].range = {
+                    min: definition.min,
+                    max: definition.max
+                };
+            }
+            
+            if (definition.pattern) {
+                docs.fields[field].pattern = definition.pattern.toString();
+            }
+            
+            if (definition.dependsOn) {
+                docs.fields[field].dependsOn = definition.dependsOn;
+            }
+        }
+        
+        return docs;
+    }
+
+    /**
+     * Generate example configuration
+     * @param {Object} options - Generation options
+     * @returns {Object} Example configuration
+     */
+    generateExample(options = {}) {
+        const { includeOptional = true, useDefaults = true } = options;
+        const example = {};
+        
+        for (const [field, definition] of Object.entries(this.schema.fields)) {
+            if (this.schema.required.includes(field) || (includeOptional && definition.optional)) {
+                if (definition.example !== undefined) {
+                    example[field] = definition.example;
+                } else if (useDefaults && definition.default !== undefined) {
+                    example[field] = definition.default;
+                } else {
+                    // Generate a placeholder based on type
+                    example[field] = this._generatePlaceholder(definition);
+                }
+            }
+        }
+        
+        return example;
+    }
+
+    /**
+     * Generate placeholder value based on type
+     * @private
+     */
+    _generatePlaceholder(definition) {
+        const type = Array.isArray(definition.type) ? definition.type[0] : definition.type;
+        
+        switch (type) {
+            case 'string':
+                if (definition.enum) return definition.enum[0];
+                return 'example-value';
+            case 'number':
+                if (definition.min !== undefined) return definition.min;
+                return 0;
+            case 'boolean':
+                return false;
+            case 'array':
+                return [];
+            case 'object':
+                return {};
+            default:
+                return null;
+        }
+    }
+}