adpa-enterprise-framework-automation
Version:
Modular, standards-compliant Node.js/TypeScript automation framework for enterprise requirements, project, and data management. Provides CLI and API for BABOK v3, PMBOK 7th Edition, and DMBOK 2.0 (in progress). Production-ready Express.js API with TypeSpe
210 lines • 7.57 kB
JavaScript
/**
* Validation Registry
*
* Central registry for all validation processors in the ADPA Quality Assurance Engine.
* Provides registration, discovery, and management of validation rules.
*
* This registry follows the factory pattern and enables dynamic discovery
* and execution of validation checks based on document types and context.
*
* @version 1.0.0
* @author ADPA Quality Assurance Engine Team
* @created June 2025
*/
/**
* Central registry for all validation processors
*/
export class ValidationRegistry {
static instance;
validators = new Map();
tags = new Map(); // tag -> validator IDs
constructor() { }
/**
* Get the singleton instance of the registry
*/
static getInstance() {
if (!ValidationRegistry.instance) {
ValidationRegistry.instance = new ValidationRegistry();
}
return ValidationRegistry.instance;
}
/**
* Register a new validator
* @param validator The validator to register
* @param options Registration options
*/
register(validator, options = {}) {
if (this.validators.has(validator.id)) {
console.warn(`Validator with ID '${validator.id}' is already registered. Replacing existing registration.`);
}
const registration = {
validator,
enabled: options.enabled ?? validator.defaultEnabled,
registeredAt: new Date(),
version: options.version,
metadata: options.metadata
};
this.validators.set(validator.id, registration);
// Register tags
if (options.tags) {
for (const tag of options.tags) {
if (!this.tags.has(tag)) {
this.tags.set(tag, new Set());
}
this.tags.get(tag).add(validator.id);
}
}
console.log(`✅ Registered validator: ${validator.name} (${validator.id})`);
}
/**
* Unregister a validator
* @param validatorId The ID of the validator to remove
*/
unregister(validatorId) {
const removed = this.validators.delete(validatorId);
// Remove from tags
for (const [tag, validatorIds] of this.tags) {
validatorIds.delete(validatorId);
if (validatorIds.size === 0) {
this.tags.delete(tag);
}
}
if (removed) {
console.log(`🗑️ Unregistered validator: ${validatorId}`);
}
return removed;
}
/**
* Enable or disable a validator
* @param validatorId The validator ID
* @param enabled Whether to enable or disable
*/
setEnabled(validatorId, enabled) {
const registration = this.validators.get(validatorId);
if (registration) {
registration.enabled = enabled;
console.log(`${enabled ? '✅' : '❌'} ${enabled ? 'Enabled' : 'Disabled'} validator: ${validatorId}`);
return true;
}
return false;
}
/**
* Get all registered validators matching the filter
* @param filter Optional filter criteria
* @returns Array of validator registrations
*/
getValidators(filter) {
let validatorList = Array.from(this.validators.values());
if (!filter) {
return validatorList;
}
// Apply filters
if (filter.enabledOnly !== undefined) {
validatorList = validatorList.filter(reg => reg.enabled === filter.enabledOnly);
}
if (filter.validatorIds) {
validatorList = validatorList.filter(reg => filter.validatorIds.includes(reg.validator.id));
}
if (filter.documentTypes) {
validatorList = validatorList.filter(reg => reg.validator.isApplicable(filter.documentTypes));
}
if (filter.minPriority !== undefined) {
validatorList = validatorList.filter(reg => reg.validator.priority >= filter.minPriority);
}
if (filter.maxPriority !== undefined) {
validatorList = validatorList.filter(reg => reg.validator.priority <= filter.maxPriority);
}
if (filter.tags) {
const matchingValidatorIds = new Set();
for (const tag of filter.tags) {
const tagValidators = this.tags.get(tag);
if (tagValidators) {
for (const validatorId of tagValidators) {
matchingValidatorIds.add(validatorId);
}
}
}
validatorList = validatorList.filter(reg => matchingValidatorIds.has(reg.validator.id));
}
// Sort by priority (1 = highest priority)
return validatorList.sort((a, b) => a.validator.priority - b.validator.priority);
}
/**
* Get a specific validator by ID
* @param validatorId The validator ID
* @returns The validator registration or undefined
*/
getValidator(validatorId) {
return this.validators.get(validatorId);
}
/**
* Check if a validator is registered
* @param validatorId The validator ID
* @returns Whether the validator is registered
*/
isRegistered(validatorId) {
return this.validators.has(validatorId);
}
/**
* Get all available tags
* @returns Array of tag names
*/
getTags() {
return Array.from(this.tags.keys());
}
/**
* Get validators by tag
* @param tag The tag name
* @returns Array of validator IDs with this tag
*/
getValidatorsByTag(tag) {
return Array.from(this.tags.get(tag) || []);
}
/**
* Get registry statistics
* @returns Statistics about the registry
*/
getStats() {
const validatorList = Array.from(this.validators.values());
const enabled = validatorList.filter(v => v.enabled).length;
const priorityCounts = {};
for (const reg of validatorList) {
const priority = reg.validator.priority;
priorityCounts[priority] = (priorityCounts[priority] || 0) + 1;
}
return {
totalValidators: validatorList.length,
enabledValidators: enabled,
disabledValidators: validatorList.length - enabled,
totalTags: this.tags.size,
validatorsByPriority: priorityCounts
};
}
/**
* Clear all registered validators (useful for testing)
*/
clear() {
this.validators.clear();
this.tags.clear();
console.log('🧹 Cleared all registered validators');
}
/**
* List all registered validators for debugging
*/
listValidators() {
console.log('\n📋 Registered Validators:');
console.log('========================');
const validatorList = this.getValidators();
for (const reg of validatorList) {
const status = reg.enabled ? '✅' : '❌';
console.log(`${status} [P${reg.validator.priority}] ${reg.validator.name} (${reg.validator.id})`);
console.log(` ${reg.validator.description}`);
if (reg.validator.applicableDocuments.length > 0) {
console.log(` 📄 Applies to: ${reg.validator.applicableDocuments.join(', ')}`);
}
}
const stats = this.getStats();
console.log(`\n📊 Total: ${stats.totalValidators} validators (${stats.enabledValidators} enabled, ${stats.disabledValidators} disabled)`);
}
}
//# sourceMappingURL=ValidationRegistry.js.map