@sailboat-computer/event-bus/dist/validation.js

Standardized event bus for sailboat computer v3 with resilience features and offline capabilities

"use strict";
/**
 * Event schema validation
 */
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createSchemaRegistry = exports.SchemaRegistry = void 0;
const ajv_1 = __importDefault(require("ajv"));
const utils_1 = require("./utils");
/**
 * Schema registry for event validation
 */
class SchemaRegistry {
    /**
     * Constructor
     */
    constructor() {
        /**
         * Schema map
         */
        this.schemas = new Map();
        this.ajv = new ajv_1.default({
            allErrors: true,
            removeAdditional: false,
            useDefaults: true,
            coerceTypes: false
        });
    }
    /**
     * Register a schema for an event type
     *
     * @param eventType - Event type
     * @param schema - JSON schema
     */
    registerSchema(eventType, schema) {
        if (this.schemas.has(eventType)) {
            utils_1.logger.warn(`Schema for event type ${eventType} already registered, overwriting`);
            // Remove existing schema before adding a new one
            this.ajv.removeSchema(eventType);
        }
        this.schemas.set(eventType, schema);
        this.ajv.addSchema(schema, eventType);
        utils_1.logger.debug(`Registered schema for event type ${eventType}`);
    }
    /**
     * Validate an event against its schema
     *
     * @param event - Event envelope
     * @returns Validation result
     */
    validate(event) {
        const eventType = event.type;
        if (!this.schemas.has(eventType)) {
            return {
                valid: true,
                errors: null
            };
        }
        const validate = this.ajv.getSchema(eventType);
        if (!validate) {
            utils_1.logger.warn(`Schema for event type ${eventType} not found in AJV`);
            return {
                valid: true,
                errors: null
            };
        }
        const valid = validate(event.data);
        if (!valid) {
            return {
                valid: false,
                errors: validate.errors || null
            };
        }
        return {
            valid: true,
            errors: null
        };
    }
    /**
     * Check if a schema is registered for an event type
     *
     * @param eventType - Event type
     * @returns True if a schema is registered
     */
    hasSchema(eventType) {
        return this.schemas.has(eventType);
    }
    /**
     * Get a schema for an event type
     *
     * @param eventType - Event type
     * @returns JSON schema or null if not found
     */
    getSchema(eventType) {
        return this.schemas.get(eventType) || null;
    }
    /**
     * Remove a schema for an event type
     *
     * @param eventType - Event type
     */
    removeSchema(eventType) {
        if (this.schemas.has(eventType)) {
            this.schemas.delete(eventType);
            this.ajv.removeSchema(eventType);
            utils_1.logger.debug(`Removed schema for event type ${eventType}`);
        }
    }
    /**
     * Clear all schemas
     */
    clearSchemas() {
        this.schemas.clear();
        this.ajv.removeSchema();
        utils_1.logger.debug('Cleared all schemas');
    }
}
exports.SchemaRegistry = SchemaRegistry;
/**
 * Create a schema registry
 *
 * @returns Schema registry
 */
function createSchemaRegistry() {
    return new SchemaRegistry();
}
exports.createSchemaRegistry = createSchemaRegistry;
//# sourceMappingURL=validation.js.map